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 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 getTubeIntersectionPointAndNormal( tubeMesh, baseMesh ): import math import sgBFunction_dag hairMesh = tubeMesh headMesh = baseMesh headMeshShape = sgBFunction_dag.getShape( headMesh ) dagPathHead = sgBFunction_dag.getMDagPath( headMeshShape ) intersector = om.MMeshIntersector() intersector.create( dagPathHead.node() ) hairMeshShape = sgBFunction_dag.getShape( hairMesh ) dagPathHairMesh = sgBFunction_dag.getMDagPath( hairMeshShape ) fnMesh = om.MFnMesh( dagPathHairMesh ) points = om.MPointArray() fnMesh.getPoints( points ) pointOnMesh = om.MPointOnMesh() minDist = 100000.0 minDistIndex = 0 minDistNormal = om.MVector() for i in range( points.length() ): intersector.getClosestPoint( points[i], pointOnMesh ) closePoint = om.MPoint( pointOnMesh.getPoint() ) dist = closePoint.distanceTo( points[i] ) if dist < minDist: normal = om.MVector() itNormal = om.MVector( pointOnMesh.getNormal() ) fnMesh.getVertexNormal( i, True, normal ) if math.fabs( itNormal.normal() * normal.normal() ) < 0.4: minDist = dist minDistIndex = i minDistNormal = itNormal pointMinDist = points[ minDistIndex ] normalMinDist = om.MVector() fnMesh.getVertexNormal( minDistIndex, True, normalMinDist ) srcPoint = om.MPoint( pointMinDist + normalMinDist ) ray = -normalMinDist intersectPoints = om.MPointArray() fnMesh.intersect( srcPoint, ray, intersectPoints ) if intersectPoints.length() == 1: return intersectPoints[0], minDistNormal else: bb = om.MBoundingBox() for k in range( intersectPoints.length() ): bb.expand( intersectPoints[k] ) return bb.center(), minDistNormal
def duplicateShaderToOther( first, second ): import maya.mel as mel import sgBFunction_dag if not cmds.objExists( first ): return None if not cmds.objExists( second ): return None first = sgBFunction_dag.getTransform( first ) second = sgBFunction_dag.getTransform( second ) firstShape = sgBFunction_dag.getShape( first ) secondShape = sgBFunction_dag.getShape( second ) engines = cmds.listConnections( firstShape, type='shadingEngine' ) if not engines: return None engines = list( set( engines ) ) for engine in engines: shaders = cmds.listConnections( engine+'.surfaceShader', s=1, d=0 ) engine = cmds.duplicate( engine, n= 'du_'+engine )[0] if shaders: shader = shaders[0] cmds.hyperShade( objects = shader ) selObjs = cmds.ls( sl=1, l=1 ) targetObjs = [] for selObj in selObjs: if selObj.find( '.' ) != -1: trNode, components = selObj.split( '.' ) if trNode == first: targetObjs.append( second+'.'+components ) elif selObj == firstShape: targetObjs.append( secondShape ) cmds.select( shader ) mel.eval( 'hyperShadePanelMenuCommand("hyperShadePanel1", "duplicateShadingNetwork")' ) shader = cmds.ls( sl=1 )[0] cmds.connectAttr( shader+'.outColor', engine+'.surfaceShader' ) aiShaders = cmds.listConnections( engine+'.aiSurfaceShader', s=1, d=0 ) if aiShaders: aiShader = aiShaders[0] cmds.hyperShade( objects = aiShader ) selObjs = cmds.ls( sl=1, l=1 ) cmds.select( aiShader ) mel.eval( 'hyperShadePanelMenuCommand("hyperShadePanel1", "duplicateShadingNetwork")' ) aiShader = cmds.ls( sl=1 )[0] cmds.connectAttr( aiShader+'.outColor', engine+'.aiSurfaceShader' ) for targetObj in targetObjs: cmds.sets( targetObj, e=1, forceElement=engine )
def cmdCreatePattern( arg=0 ): import sgBFunction_dag import sgBFunction_attribute PatternSize = cmds.floatField( WinA_Global.ff_patternSize, q=1, v=1 ) OffsetMult = cmds.floatField( WinA_Global.ff_offsetMult, q=1, v=1 ) sels = cmds.ls( sl=1 ) curve = sels[0] surf = sels[1] curveShape = sgBFunction_dag.getShape( curve ) surfShape = sgBFunction_dag.getShape( surf ) numSpansU = cmds.getAttr( surfShape + '.spansU' ) numSpansV = cmds.getAttr( surfShape + '.spansV' ) rebuildSurf = cmds.createNode( 'rebuildSurface' ) cmds.setAttr( rebuildSurf + '.keepCorners', 0 ) cmds.setAttr( rebuildSurf + '.spansU', numSpansU ) cmds.setAttr( rebuildSurf + '.spansV', numSpansV ) trGeo = cmds.createNode( 'transformGeometry' ) node = cmds.createNode( 'sgPatternCurveOnSurface' ) sgBFunction_attribute.addAttr( curve, ln='patternSize', min=0.1, dv=PatternSize, k=1 ) sgBFunction_attribute.addAttr( curve, ln='offsetMult', min=0.25, dv=OffsetMult, k=1 ) cmds.connectAttr( curve + '.patternSize', node + '.patternSize' ) cmds.connectAttr( curve + '.offsetMult' , node + '.offsetMult' ) newSurface = cmds.createNode( 'nurbsSurface' ) cmds.setAttr( newSurface + '.io', 1 ) cmds.connectAttr( surfShape + '.local', rebuildSurf + '.inputSurface' ) cmds.connectAttr( rebuildSurf + '.outputSurface', trGeo + '.inputGeometry' ) cmds.connectAttr( surf + '.wm', trGeo + '.transform' ) cmds.connectAttr( trGeo + '.outputGeometry', newSurface+'.create' ) cmds.connectAttr( newSurface + '.local', node + '.surface' ) cmds.connectAttr( curveShape + '.local', node + '.curve' ) surfShape = cmds.listRelatives( curve, s=1, f=1 )[0] nodes = cmds.listConnections( surfShape, s=0, d=1, type='sgPatternCurveOnSurface' ) outputNum = cmds.getAttr( nodes[0] + '.numOutput' ) for i in range( outputNum ): cons = cmds.listConnections( nodes[0] +'.outputCurves[%d]' % i ) if not cons: outputCurve = cmds.createNode( 'nurbsCurve' ) cmds.connectAttr( nodes[0] + '.outputCurves[%d]' % i, outputCurve + '.create' )
def copyFollicleAttribute( *args ): sels = cmds.ls( sl=1 ) others = sels[:-1] first = sels[-1] import sgBModel_attribute import sgBFunction_dag import sgBFunction_attribute first = sgBFunction_dag.getShape( first ) if cmds.nodeType( first ) == 'nurbsCurve': first = sgBFunction_dag.getFollicleFromCurve( first ) for i in range( len( others ) ): other = sgBFunction_dag.getShape( others[i] ) if cmds.nodeType( other ) == 'nurbsCurve': other = sgBFunction_dag.getFollicleFromCurve( other ) others[i] = other follicleRampAttrList = sgBModel_attribute.follicleRampAttrList follicleNormalAttrList = sgBModel_attribute.follicleNormalAttrList fnNode = om.MFnDependencyNode( sgBFunction_dag.getMObject( first ) ) rampAttrNames = [] rampValues = [] for rampAttr in follicleRampAttrList: print "node name : ", fnNode.name() plugAttr = fnNode.findPlug( rampAttr ) print rampAttr for other in others: sgBFunction_attribute.removeMultiInstances( other, rampAttr ) for j in range( plugAttr.numElements() ): rampAttrNames.append( plugAttr[j].name().split( '.' )[-1] ) rampValues.append( cmds.getAttr( plugAttr[j].name() )[0] ) for other in others: for i in range( len( rampAttrNames ) ): cmds.setAttr( other+'.'+rampAttrNames[i], *rampValues[i] ) for normalAttr in follicleNormalAttrList: attrValue = cmds.getAttr( first+'.'+normalAttr ) for other in others: try:cmds.setAttr( other+'.'+normalAttr, attrValue ) except:pass
def createFollicleFromSurfacePoint( surfacePoint ): import sgBFunction_dag surfaceNode, noneArrangeStr = surfacePoint.split( '.uv[' ) uvStrs = noneArrangeStr.replace( ']', '' ).split( '[' ) uv = [ float( uvStrs[0] ), float( uvStrs[1] ) ] surfaceNode = sgBFunction_dag.getShape( surfaceNode ) minMaxRangeU = cmds.getAttr( surfaceNode+'.minMaxRangeU' )[0] minMaxRangeV = cmds.getAttr( surfaceNode+'.minMaxRangeV' )[0] divRateU = minMaxRangeU[1] - minMaxRangeU[0] divRateV = minMaxRangeV[1] - minMaxRangeV[0] follicleNode = cmds.createNode( 'follicle' ) cmds.setAttr( follicleNode+'.parameterU', uv[0]/divRateU ) cmds.setAttr( follicleNode+'.parameterV', uv[1]/divRateV ) cmds.connectAttr( surfaceNode+'.local', follicleNode+'.inputSurface' ) cmds.connectAttr( surfaceNode+'.wm', follicleNode+'.inputWorldMatrix' ) follicleObj = sgBFunction_dag.getTransform( follicleNode ) cmds.setAttr( follicleObj+'.inheritsTransform', 0 ) cmds.connectAttr( follicleNode+'.outTranslate', follicleObj+'.t' ) cmds.connectAttr( follicleNode+'.outRotate', follicleObj+'.r' ) return follicleObj
def createFollicleOnVertices( vertices ): import sgBFunction_dag import sgBFunction_mesh vertices = cmds.ls( vertices, fl=1 ) for vertex in vertices: vtxPos = cmds.xform( vertex, q=1, ws=1, t=1 ) mesh = vertex.split( '.' )[0] meshShape = sgBFunction_dag.getShape( mesh ) u, v = sgBFunction_mesh.getUVAtPoint( vtxPos, mesh ) follicleNode = cmds.createNode( 'follicle' ) follicle = cmds.listRelatives( follicleNode, p=1, f=1 )[0] cmds.connectAttr( meshShape+'.outMesh', follicleNode+'.inputMesh' ) cmds.connectAttr( meshShape+'.wm', follicleNode+'.inputWorldMatrix' ) cmds.setAttr( follicleNode+'.parameterU', u ) cmds.setAttr( follicleNode+'.parameterV', v ) cmds.connectAttr( follicleNode+'.outTranslate', follicle+'.t' ) cmds.connectAttr( follicleNode+'.outRotate', follicle+'.r' )
def createRivetOnSurfacePoint( surfacePoint, firstDirection='u' ): import sgBFunction_dag import sgBFunction_attribute if firstDirection.lower() == 'u': fString = 'U' sString = 'V' else: fString = 'V' sString = 'U' surfaceName, uv = surfacePoint.split( '.uv' ) surfaceName = sgBFunction_dag.getShape( surfaceName ) uvSplits = uv.split( '][' ) uValue = float( uvSplits[0].replace( '[', '' ) ) vValue = float( uvSplits[1].replace( ']', '' ) ) pointOnSurf = cmds.createNode( 'pointOnSurfaceInfo' ) vectorNode = cmds.createNode( 'vectorProduct' ) fbfNode = cmds.createNode( 'fourByFourMatrix' ) mmdcNode = cmds.createNode( 'multMatrixDecompose' ) rivetNode = cmds.createNode( 'transform' ) cmds.setAttr( pointOnSurf+'.u', uValue ) cmds.setAttr( pointOnSurf+'.v', vValue ) cmds.setAttr( vectorNode+'.operation', 2 ) cmds.setAttr( rivetNode+'.dla',1 ) cmds.setAttr( rivetNode+'.dh', 1 ) cmds.connectAttr( surfaceName +'.worldSpace[0]', pointOnSurf+'.inputSurface' ) cmds.connectAttr( pointOnSurf+'.tangent%s' % fString, vectorNode+'.input1' ) cmds.connectAttr( pointOnSurf+'.tangent%s' % sString, vectorNode+'.input2' ) cmds.connectAttr( pointOnSurf+'.tangent%sx' % fString, fbfNode+'.i00' ) cmds.connectAttr( pointOnSurf+'.tangent%sy' % fString, fbfNode+'.i01' ) cmds.connectAttr( pointOnSurf+'.tangent%sz' % fString, fbfNode+'.i02' ) cmds.connectAttr( pointOnSurf+'.tangent%sx' % sString, fbfNode+'.i10' ) cmds.connectAttr( pointOnSurf+'.tangent%sy' % sString, fbfNode+'.i11' ) cmds.connectAttr( pointOnSurf+'.tangent%sz' % sString, fbfNode+'.i12' ) cmds.connectAttr( vectorNode+'.outputX', fbfNode+'.i20' ) cmds.connectAttr( vectorNode+'.outputY', fbfNode+'.i21' ) cmds.connectAttr( vectorNode+'.outputZ', fbfNode+'.i22' ) cmds.connectAttr( pointOnSurf+'.positionX', fbfNode+'.i30' ) cmds.connectAttr( pointOnSurf+'.positionY', fbfNode+'.i31' ) cmds.connectAttr( pointOnSurf+'.positionZ', fbfNode+'.i32' ) cmds.connectAttr( fbfNode+'.output', mmdcNode+'.i[0]' ) cmds.connectAttr( rivetNode+'.pim', mmdcNode+'.i[1]' ) cmds.connectAttr( mmdcNode+'.ot', rivetNode+'.t' ) cmds.connectAttr( mmdcNode+'.or', rivetNode+'.r' ) sgBFunction_attribute.addAttr( rivetNode, ln='paramU', min=0, dv=uValue, k=1 ) sgBFunction_attribute.addAttr( rivetNode, ln='paramV', min=0, dv=vValue, k=1 ) cmds.connectAttr( rivetNode+'.paramU', pointOnSurf+'.u' ) cmds.connectAttr( rivetNode+'.paramV', pointOnSurf+'.v' )
def surfaceColorAtPoint( surfaceNode, position ): import sgBFunction_dag def getCloseNode( surfaceNode ): closeNode = cmds.listConnections( surfaceNode+'.worldSpace', type='closestPointOnSurface' ) if closeNode: return closeNode[0] closeNode = cmds.createNode( 'closestPointOnSurface' ) cmds.connectAttr( surfaceNode+'.worldSpace', closeNode+'.inputSurface' ) return closeNode surfaceNode = sgBFunction_dag.getShape( surfaceNode ) closeNode = getCloseNode( surfaceNode ) cmds.setAttr( closeNode+'.inPosition', *position ) shadingEngines = sgBFunction_dag.getShadingEngines( surfaceNode ) if not shadingEngines: return None shader = cmds.listConnections( shadingEngines[0]+'.surfaceShader', s=1, d=0 ) texture = cmds.listConnections( shader[0]+'.color', s=1, d=0 ) if not texture: return None uValue = cmds.getAttr( closeNode+'.parameterU' ) vValue = cmds.getAttr( closeNode+'.parameterV' ) return cmds.colorAtPoint( texture[0], u=uValue, v=vValue )
def displayModConnect( displayMods ): import sgBFunction_dag import sgBFunction_convert import sgBFunction_connection displayMods = sgBFunction_convert.singleToList( displayMods ) for displayMod in displayMods: origMod = displayMod.replace( 'display_', '' ) sgBFunction_connection.constraintAll( origMod, displayMod ) displayModShape = sgBFunction_dag.getShape( displayMod ) origModShape = sgBFunction_dag.getShape( origMod ) cmds.connectAttr( origModShape+'.outMesh', displayModShape+'.inMesh' )
def createControllerOnTarget( target, pivotCtlOn=True ): import sgBFunction_connection import sgBFunction_dag import sgBModel_data targetPos = cmds.getAttr( target+'.wm' ) targetP = cmds.listRelatives( target, p=1, f=1 )[0] targetName = target.split( '|' )[-1] ctl = cmds.circle( n='CTL_' + targetName )[0] ctlChild = cmds.createNode( 'transform', n='CTLChild_'+targetName );ctlChild = cmds.parent( ctlChild, ctl )[0] pivCtl = cmds.createNode( 'transform', n='PivCTL_'+targetName ); cmds.setAttr( pivCtl+'.dh', 1 ) cmds.setAttr( pivCtl+'.overrideEnabled', 1 ) cmds.setAttr( pivCtl+'.overrideColor', 18 ) ctlP = cmds.group( ctl, n='P'+ctl ) ctlPPiv = cmds.group( ctlP, pivCtl, n='Piv' + ctlP ) cmds.xform( ctlPPiv, ws=1, matrix=targetPos ) cloneObject = sgBFunction_dag.getConstrainedObject( targetP ) ctlPPiv = cmds.parent( ctlPPiv, cloneObject )[0] cmds.xform( pivCtl, os=1, matrix= sgBModel_data.getDefaultMatrix() ) ctl = cmds.listRelatives( ctlP, c=1, f=1 )[0] sgBFunction_connection.getSourceConnection( target, ctlPPiv ) for attr in [ 't', 'tx', 'ty', 'tz', 'r', 'rx', 'ry', 'rz', 's', 'sx', 'sy', 'sz', 'sh' ]: cons = cmds.listConnections( target+'.'+attr, s=1, d=0, p=1, c=1 ) if not cons: continue for i in range( 0, len( cons ), 2 ): cmds.disconnectAttr( cons[i+1], cons[i] ) sgBFunction_connection.constraintAll( ctlChild, target ) cmds.connectAttr( pivCtl+'.t', ctlP+'.t' ) cmds.connectAttr( pivCtl+'.r', ctlP+'.r' ) cmds.connectAttr( pivCtl+'.s', ctlP+'.s' ) cmds.connectAttr( pivCtl+'.sh', ctlP+'.sh' ) mmdcCtlChild = cmds.createNode( 'multMatrixDecompose' ) cmds.connectAttr( ctlPPiv+'.wm', mmdcCtlChild+'.i[0]' ) cmds.connectAttr( pivCtl+'.wim', mmdcCtlChild+'.i[1]' ) cmds.connectAttr( mmdcCtlChild+'.ot', ctlChild+'.t' ) cmds.connectAttr( mmdcCtlChild+'.or', ctlChild+'.r' ) cmds.connectAttr( mmdcCtlChild+'.os', ctlChild+'.s' ) cmds.connectAttr( mmdcCtlChild+'.osh', ctlChild+'.sh' ) ctlShape = sgBFunction_dag.getShape( ctl ) circleNode = cmds.listConnections( ctlShape+'.create', s=1, d=0 )[0] mm = cmds.createNode( 'multMatrix' ) trGeo = cmds.createNode( 'transformGeometry' ) cmds.connectAttr( ctlPPiv+'.wm', mm+'.i[0]' ) cmds.connectAttr( pivCtl+'.wim', mm+'.i[1]' ) cmds.connectAttr( circleNode+'.outputCurve', trGeo+'.inputGeometry' ) cmds.connectAttr( mm+'.matrixSum', trGeo+'.transform' ) cmds.connectAttr( trGeo+'.outputGeometry', ctlShape+'.create', f=1 ) return ctl
def getCurveLength(target ): import sgBFunction_dag targetShape = sgBFunction_dag.getShape( target ) fnCurve = om.MFnNurbsCurve( sgBFunction_dag.getMDagPath( targetShape ) ) return fnCurve.length()
def export( *args ): import sgBFunction_fileAndPath import sgBFunction_dag exportPath = cmds.textField( WinA_Global.txf_export, q=1, tx=1 ) minFrame = cmds.intField( WinA_Global.fld_startFrame, q=1, v=1 ) maxFrame = cmds.intField( WinA_Global.fld_endFrame, q=1, v=1 ) exportPath = exportPath.replace( '\\', '/' ) folderPath = '/'.join( exportPath.split( '/' )[-1:] ) sgBFunction_fileAndPath.makeFolder( folderPath ) sels = cmds.ls( sl=1 ) cams = [] for sel in sels: selShape = sgBFunction_dag.getShape( sel ) if cmds.nodeType( selShape ) == 'camera': cams.append( sel ) import sgBFunction_scene sgBFunction_scene.doBake( exportPath, minFrame, maxFrame ) WinA_Cmd.write_windowInfo()
def getMeshAndIndices( vertices ): meshName = sgBFunction_dag.getShape( vertices[0].split( '.' )[0] ) indices = [] for vtx in vertices: vtxName = vtx.split( '.' )[1] index = int( vtxName.split( '[' )[-1].replace( ']', '' ) ) indices.append( index ) return meshName, indices
def __init__(self, centerCurves, mesh ): import sgBFunction_dag self.centerCurves = centerCurves meshShape = sgBFunction_dag.getShape( mesh ) dagPath = sgBFunction_dag.getMDagPath( meshShape ) self.fnMesh = om.MFnMesh( dagPath ) self.mtxMesh = dagPath.inclusiveMatrix()
def copyShapeAttr( source, target, ud=False ): import sgBFunction_dag sourceShape = sgBFunction_dag.getShape( source ) targetShape = sgBFunction_dag.getShape( target ) udAttrs = cmds.listAttr( sourceShape, ud=1 ) fpAttrs = cmds.listAttr( sourceShape, fp=1 ) attrs = [] if udAttrs: attrs += udAttrs if fpAttrs: attrs += fpAttrs for attr in attrs: if attr.find( '.' ) != -1: continue if not cmds.attributeQuery( attr, node = sourceShape, writable=1 ): continue copyAttribute( sourceShape+'.'+attr, targetShape )
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 getMatricesFromCurve( curve, aimIndex = 0, vUpVector=None ): import sgBFunction_dag curveShape = sgBFunction_dag.getShape( curve ) curvePath = sgBFunction_dag.getMDagPath( curveShape ) mtxCurve = curvePath.inclusiveMatrix() fnCurve = om.MFnNurbsCurve( curvePath ) minParam = fnCurve.findParamFromLength( 0 ) maxParam = fnCurve.findParamFromLength( fnCurve.length() ) numSpans = fnCurve.numSpans() lengthParam = maxParam - minParam eachParam = lengthParam / ( numSpans - 1 ) if not vUpVector: vUp = om.MVector( 0, 1, 0 ) else: vUp = vUpVector mtxArr = [] for i in range( numSpans ): point = om.MPoint() fnCurve.getPointAtParam( eachParam * i, point ) vTangent = fnCurve.tangent( eachParam * i ) * mtxCurve vCross = vTangent ^ vUp vUp = vCross ^ vTangent vTangent.normalize() vUp.normalize() vCross.normalize() mtx = [ float(i%5 == 0) for i in range( 16 ) ] indexAim = (3+aimIndex)%3 indexUp = (3+aimIndex+1)%3 indexCross = (3+aimIndex+2)%3 mtx[ indexAim*4+0 ] = vTangent.x mtx[ indexAim*4+1 ] = vTangent.y mtx[ indexAim*4+2 ] = vTangent.z mtx[ indexUp*4+0 ] = vUp.x mtx[ indexUp*4+1 ] = vUp.y mtx[ indexUp*4+2 ] = vUp.z mtx[ indexCross*4+0 ] = vCross.x mtx[ indexCross*4+1 ] = vCross.y mtx[ indexCross*4+2 ] = vCross.z mtx[ 3*4+0 ] = point.x mtx[ 3*4+1 ] = point.y mtx[ 3*4+2 ] = point.z mtxArr.append( mtx ) return mtxArr
def makeDisplayMod_deformed( baseModel ): import sgBFunction_dag targetShape = cmds.createNode( 'mesh' ) baseShape = sgBFunction_dag.getShape( baseModel ) cmds.connectAttr( baseShape+'.outMesh', targetShape+'.inMesh' ) target = cmds.listRelatives( targetShape, p=1, f=1 )[0] cmds.select( target ) cmds.sets( e=1, forceElement='initialShadingGroup' ) cmds.xform( target, ws=1, matrix= cmds.getAttr( baseModel+'.wm' ) ) return cmds.rename( target, 'display_' + baseModel.split( '|' )[-1] )
def getKnots( target ): import sgBFunction_dag target = sgBFunction_dag.getShape( target ) fnCurve = om.MFnNurbsCurve( sgBFunction_dag.getMObject( target ) ) dArr = om.MDoubleArray() fnCurve.getKnots( dArr ) return dArr
def setRandomColor( targets, each=True ): import sgBModel_data import sgBFunction_dag if each: for target in targets: shape = sgBFunction_dag.getShape( target ) cmds.setAttr( shape+'.overrideEnabled', True ) cmds.setAttr( shape+'.overrideColor', sgBModel_data.setAniColorNum ) sgBModel_data.setAniColorNum = ( sgBModel_data.setAniColorNum + 1 ) % 32 if sgBModel_data.setAniColorNum in [ 16, 19, 20, 1 ]: sgBModel_data.setAniColorNum +=1 else: for target in targets: shape = sgBFunction_dag.getShape( target ) cmds.setAttr( shape+'.overrideEnabled', True ) cmds.setAttr( shape+'.overrideColor', sgBModel_data.setAniColorNum )
def makeSparateShader( targetObject ): import random import maya.OpenMaya as om import sgBFunction_dag import sgBFunction_base import copy sgBFunction_base.autoLoadPlugin( 'sgMesh' ) cmds.sgGetMeshElementInfo( targetObject, set=1 ) targetShape = sgBFunction_dag.getShape( targetObject ) dagPathShape = sgBFunction_dag.getMDagPath( targetShape ) numElement = cmds.sgGetMeshElementInfo( ne=1 ) numFaces = cmds.sgGetMeshElementInfo( np=1 ) faceIndices = cmds.sgGetMeshElementInfo( fi=1 ) for i in range( numElement ): startFaceIndex = 0 lastFaceIndex = 0 for j in range( i ): startFaceIndex += int( numFaces[j] ) for j in range( i+1 ): lastFaceIndex += int( numFaces[j] ) compArray = om.MIntArray() compArray.setLength( int( numFaces[i] ) ) for j in range( startFaceIndex, lastFaceIndex ): compArray.set( faceIndices[j], j-startFaceIndex ) blinnShader = cmds.shadingNode( 'blinn', asShader=1 ) blinnSet = cmds.sets( renderable=1, noSurfaceShader=1, empty=1, name='blinnSG' ) cmds.connectAttr( blinnShader+'.outColor', blinnSet+'.surfaceShader', f=1 ) colorR = random.uniform( 0, 1 ) colorG = random.uniform( 0, 1 ) colorB = random.uniform( 0, 1 ) cmds.setAttr( blinnShader+'.color', colorR, colorG, colorB, type='double3' ) singleComp = om.MFnSingleIndexedComponent() singleCompObj = singleComp.create( om.MFn.kMeshPolygonComponent ) singleComp.addElements( compArray ) selList = om.MSelectionList() selList.add( dagPathShape, singleCompObj ) om.MGlobal.selectCommand( selList ) cmds.sets( e=1, forceElement=blinnSet )
def separateMeshBySkinWeight2( meshObj ): import sgBFunction_connection skinClusters = sgBFunction_dag.getNodeFromHistory( meshObj, 'skinCluster' ) meshShape = sgBFunction_dag.getShape( meshObj ) if not skinClusters: return [] skinCluster = skinClusters[0] fnMesh = om.MFnMesh( sgBFunction_dag.getMDagPath( meshShape ) ) jntsPerVertices = JointsPerVertices( skinCluster ) polygonsPerJointArray = [ PolygonsPerJoint2( meshShape ) for i in range( len( jntsPerVertices.existConnectJoints ) ) ] vtxCountsPerPolygon = om.MIntArray() vtxIndices = om.MIntArray() fnMesh.getVertices( vtxCountsPerPolygon, vtxIndices ) for i in range( fnMesh.numVertices() ): jointLogicalIndex = jntsPerVertices.getJointIndex( i ) physicalIndex = jntsPerVertices.jointLogicalIndexMap[ jointLogicalIndex ] polygonsPerJointArray[ physicalIndex ].check( i ) meshs = [] for i in range( len( polygonsPerJointArray ) ): targetJoint = om.MFnDagNode( jntsPerVertices.existConnectJoints[i] ).fullPathName() mesh = polygonsPerJointArray[i].buildMesh2() meshShape = sgBFunction_dag.getShape( mesh ) fnMesh = om.MFnMesh( sgBFunction_dag.getMDagPath( meshShape ) ) print fnMesh.numPolygons(), targetJoint mesh = cmds.rename( mesh, targetJoint.split( '|' )[-1] + '_mesh' ) cmds.sets( mesh, e=1, forceElement='initialShadingGroup' ) meshs.append( mesh ) sgBFunction_connection.bindConnect( mesh, targetJoint ) return meshs
def getCurveInfo_localSpace( curve ): import sgBFunction_dag curveShape = sgBFunction_dag.getShape( curve ) cons = cmds.listConnections( curveShape+'.local', d=1, s=0 ) if not cons: info = cmds.createNode( 'curveInfo' ) cmds.connectAttr( curveShape+'.local', info+'.inputCurve' ) return info else: return cons[0]
def getNodeFromMesh( mesh, isFirst=True ): if cmds.objectType( mesh ) == 'transform': mesh = sgBFunction_dag.getShape( mesh ) cons = cmds.listConnections( mesh+'.wm', type='sgMatrixFromVertices' ) if cons: return cons[0] node = cmds.createNode( 'sgMatrixFromVertices' ) cmds.connectAttr( mesh+'.outMesh', node+'.inputMesh' ) cmds.connectAttr( mesh+'.wm', node+'.inputMeshMatrix' ) return node
def addSquashFromCurve( target, curve ): import sgBFunction_curve import sgBFunction_dag import sgBFunction_mscriptUtil import math sgBFunction_curve.addDistanceAttribute( curve ) squashNode = cmds.createNode( 'squash' ) cmds.connectAttr( curve + '.initCurveLength', squashNode+'.lengthOriginal' ) cmds.connectAttr( curve + '.curveLength', squashNode+'.lengthModify' ) divNode = cmds.createNode( 'multiplyDivide' ) cmds.setAttr( divNode+'.operation', 2 ) cmds.connectAttr( curve+'.curveLength', divNode+'.input1X' ) cmds.connectAttr( curve+'.initCurveLength', divNode+'.input2X' ) curveShape = sgBFunction_dag.getShape( curve ) mtxTarget = sgBFunction_dag.getMDagPath( target ).inclusiveMatrix() fnCurve = om.MFnNurbsCurve( sgBFunction_dag.getMDagPath( curveShape ) ) mtxCurve = sgBFunction_dag.getMDagPath( curveShape ).inclusiveMatrix() pointTarget = om.MPoint( mtxTarget( 3, 0 ), mtxTarget( 3, 1 ), mtxTarget( 3, 2 ) ) * mtxCurve.inverse() ptrParam, utilParam = sgBFunction_mscriptUtil.getDoublePtr() fnCurve.getParamAtPoint( pointTarget, ptrParam ) param = utilParam.getDouble( ptrParam ) tangent = fnCurve.tangent( param ) vX = om.MVector( mtxTarget( 0, 0 ), mtxTarget( 0, 1 ), mtxTarget( 0, 2 ) ) vY = om.MVector( mtxTarget( 1, 0 ), mtxTarget( 1, 1 ), mtxTarget( 1, 2 ) ) vZ = om.MVector( mtxTarget( 2, 0 ), mtxTarget( 2, 1 ), mtxTarget( 2, 2 ) ) dotX = math.fabs( tangent * vX ) dotY = math.fabs( tangent * vY ) dotZ = math.fabs( tangent * vZ ) if dotX > dotY and dotX > dotZ: cmds.connectAttr( divNode+'.outputX', target+'.scaleX', f=1 ) cmds.connectAttr( squashNode+'.output', target+'.scaleY', f=1 ) cmds.connectAttr( squashNode+'.output', target+'.scaleZ', f=1 ) elif dotY > dotZ and dotY > dotX: cmds.connectAttr( squashNode+'.output', target+'.scaleX', f=1 ) cmds.connectAttr( divNode+'.outputX', target+'.scaleY', f=1 ) cmds.connectAttr( squashNode+'.output', target+'.scaleZ', f=1 ) elif dotZ > dotX and dotZ > dotY: cmds.connectAttr( squashNode+'.output', target+'.scaleX', f=1 ) cmds.connectAttr( squashNode+'.output', target+'.scaleY', f=1 ) cmds.connectAttr( divNode+'.outputX', target+'.scaleZ', f=1 )
def setAniColor( targets ): import sgBModel_data import sgBFunction_dag for target in targets: shape = sgBFunction_dag.getShape( target ) cmds.setAttr( shape+'.overrideEnabled', True ) cmds.setAttr( shape+'.overrideColor', sgBModel_data.setAniColorNum ) sgBModel_data.setAniColorNum = ( sgBModel_data.setAniColorNum + 1 ) % 32 if sgBModel_data.setAniColorNum in [ 16, 19 ]: sgBModel_data.setAniColorNum +=1
def rebuildByMinMaxSpans(curves, minSpans, maxSpans): import sgBFunction_dag sels = sgBFunction_dag.getChildrenShapeExists(curves) lengthList = [] minLength = 10000000.0 maxLength = 0.0 targetCurves = [] for sel in sels: selShape = sgBFunction_dag.getShape(sel) if not selShape: continue if not cmds.nodeType(selShape) == 'nurbsCurve': continue fnCurve = om.MFnNurbsCurve(sgBFunction_dag.getMDagPath(selShape)) curveLength = fnCurve.length() if curveLength < minLength: minLength = curveLength if curveLength > maxLength: maxLength = curveLength targetCurves.append(sel) lengthList.append(fnCurve.length()) diffSpans = maxSpans - minSpans diffLength = maxLength - minLength for i in range(len(targetCurves)): lengthRate = (lengthList[i] - minLength) / diffLength spansRate = lengthRate * diffSpans spans = spansRate + minSpans cmds.rebuildCurve(targetCurves[i], rpo=1, rt=0, end=1, kr=2, kcp=0, kep=1, kt=1, s=spans, d=3, tol=0.01)
def getDeformedObjectsFromGroup(targets): import sgBFunction_dag targets = sgBFunction_dag.getChildrenShapeExists(targets) if not targets: return [] returnTransforms = [] for target in targets: targetShape = sgBFunction_dag.getShape(target) nodeType = cmds.nodeType(targetShape) if nodeType == 'mesh': inputAttr = 'inMesh' elif nodeType in ['nurbsCurve', 'nurbsSurface']: inputAttr = 'create' cons = cmds.listConnections(targetShape + '.' + inputAttr, s=1, d=0) if not cons: continue returnTransforms.append(target) return list(set(returnTransforms))
def importCache( mesh, xmlFilePath ): import sgBFunction_dag import maya.cmds as cmds mesh = sgBFunction_dag.getShape( mesh ) xmlFileSplits = xmlFilePath.split( '/' ) cachePath = '/'.join( xmlFileSplits[:-1] ) cacheName = xmlFileSplits[-1].split( '.' )[0] deformer = cmds.createNode( 'historySwitch' ) cacheNode = cmds.createNode( 'cacheFile' ) cmds.connectAttr( cacheNode+'.outCacheData[0]', deformer+'.inPositions[0]') cmds.connectAttr( cacheNode+'.inRange', deformer+'.playFromCache' ) cmds.connectAttr( 'time1.outTime', cacheNode+'.time' ) cmds.setAttr( cacheNode+'.cachePath', cachePath, type='string' ) cmds.setAttr( cacheNode+'.cacheName', cacheName, type='string' ) #print "xml filePath : ", xmlFilePath startFrame, endFrame = getStartAndEndFrameFromXmlFile( xmlFilePath ) cmds.setAttr( cacheNode+'.startFrame', -10000 ) cmds.setAttr( cacheNode+'.sourceStart', -10000 ) cmds.setAttr( cacheNode+'.sourceEnd', 10000 ) cmds.setAttr( cacheNode+'.originalStart', startFrame ) cmds.setAttr( cacheNode+'.originalEnd', endFrame ) cmds.select( mesh ) cmds.DeleteHistory() meshP = cmds.listRelatives( mesh, p=1, f=1 )[0] for shape in cmds.listRelatives( meshP, s=1, f=1 ): if cmds.getAttr( shape+'.io' ): cmds.delete( shape ) print cmds.listRelatives( meshP, s=1 ) origMesh = sgBFunction_dag.addIOShape( mesh ) if cmds.nodeType( mesh ) == 'mesh': cmds.connectAttr( origMesh+'.worldMesh', deformer+'.undeformedGeometry[0]' ) cmds.connectAttr( deformer+'.outputGeometry[0]', mesh+'.inMesh', f=1 ) elif cmds.nodeType( mesh ) in [ 'nurbsCurve', 'nurbsSurface' ]: cmds.connectAttr( origMesh+'.worldSpace', deformer+'.undeformedGeometry[0]' ) cmds.connectAttr( deformer+'.outputGeometry[0]', mesh+'.create', f=1 )
def getDeformedObjectsFromGroup( targets ): import sgBFunction_dag targets = sgBFunction_dag.getChildrenShapeExists( targets ) if not targets: return [] returnTransforms = [] for target in targets: targetShape = sgBFunction_dag.getShape( target ) nodeType = cmds.nodeType( targetShape ) if nodeType == 'mesh': inputAttr = 'inMesh' elif nodeType in ['nurbsCurve', 'nurbsSurface']: inputAttr = 'create' cons = cmds.listConnections( targetShape+'.'+inputAttr, s=1, d=0 ) if not cons: continue returnTransforms.append( target ) return list( set( returnTransforms ) )
def createClosestPointObjectOnCurve( target, curve, attach=False ): import sgBFunction_dag import sgBFunction_curve import sgBFunction_attribute crvShape = sgBFunction_dag.getShape( curve ) crvMin, crvMax = cmds.getAttr( crvShape + '.minMaxValue' )[0] tr = cmds.createNode( 'transform' ) cmds.setAttr( tr + '.dh', 1 ) sgBFunction_attribute.addAttr( tr, ln='param', min=crvMin, max=crvMax, k=1 ) if attach: nearInfo = cmds.createNode( 'nearestPointOnCurve' ) dcmp = cmds.createNode( 'decomposeMatrix' ) cmds.connectAttr( crvShape + '.worldSpace', nearInfo + '.inputCurve' ) cmds.connectAttr( target + '.wm', dcmp + '.imat' ) cmds.connectAttr( dcmp + '.ot', nearInfo + '.inPosition' ) vectorProduct = cmds.createNode( 'vectorProduct' ) cmds.setAttr( vectorProduct + '.operation', 4 ) cmds.connectAttr( nearInfo+'.position', vectorProduct+'.input1' ) cmds.connectAttr( tr+'.pim', vectorProduct + '.matrix' ) cmds.connectAttr( vectorProduct + '.output', tr+'.t' ) else: pointOnCurve = cmds.createNode( 'pointOnCurveInfo' ) cmds.connectAttr( crvShape + '.worldSpace', pointOnCurve + '.inputCurve' ) vectorProduct = cmds.createNode( 'vectorProduct' ) cmds.setAttr( vectorProduct + '.operation', 4 ) cmds.connectAttr( pointOnCurve+'.position', vectorProduct+'.input1' ) cmds.connectAttr( tr+'.pim', vectorProduct + '.matrix' ) cmds.connectAttr( vectorProduct + '.output', tr+'.t' ) parameter = sgBFunction_curve.getClosestParameter( target, curve ) cmds.setAttr( tr + '.param', parameter ) cmds.connectAttr( tr + '.param', pointOnCurve + '.parameter' ) return tr
def createClosestPointObjectOnCurve(target, curve, attach=False): import sgBFunction_dag import sgBFunction_curve import sgBFunction_attribute crvShape = sgBFunction_dag.getShape(curve) crvMin, crvMax = cmds.getAttr(crvShape + '.minMaxValue')[0] tr = cmds.createNode('transform') cmds.setAttr(tr + '.dh', 1) sgBFunction_attribute.addAttr(tr, ln='param', min=crvMin, max=crvMax, k=1) if attach: nearInfo = cmds.createNode('nearestPointOnCurve') dcmp = cmds.createNode('decomposeMatrix') cmds.connectAttr(crvShape + '.worldSpace', nearInfo + '.inputCurve') cmds.connectAttr(target + '.wm', dcmp + '.imat') cmds.connectAttr(dcmp + '.ot', nearInfo + '.inPosition') vectorProduct = cmds.createNode('vectorProduct') cmds.setAttr(vectorProduct + '.operation', 4) cmds.connectAttr(nearInfo + '.position', vectorProduct + '.input1') cmds.connectAttr(tr + '.pim', vectorProduct + '.matrix') cmds.connectAttr(vectorProduct + '.output', tr + '.t') else: pointOnCurve = cmds.createNode('pointOnCurveInfo') cmds.connectAttr(crvShape + '.worldSpace', pointOnCurve + '.inputCurve') vectorProduct = cmds.createNode('vectorProduct') cmds.setAttr(vectorProduct + '.operation', 4) cmds.connectAttr(pointOnCurve + '.position', vectorProduct + '.input1') cmds.connectAttr(tr + '.pim', vectorProduct + '.matrix') cmds.connectAttr(vectorProduct + '.output', tr + '.t') parameter = sgBFunction_curve.getClosestParameter(target, curve) cmds.setAttr(tr + '.param', parameter) cmds.connectAttr(tr + '.param', pointOnCurve + '.parameter') return tr
def addWobbleCurve(targetCurves): import sgBFunction_convert import sgBFunction_dag targetCurves = sgBFunction_convert.singleToList(targetCurves) targetCurves = sgBFunction_dag.getChildrenShapeExists(targetCurves) for targetCurve in targetCurves: targetShape = sgBFunction_dag.getShape(targetCurve) cons = cmds.listConnections(targetShape + '.create', p=1, c=1, s=1, d=0) sourceAttr = '' if not cons: origShape = cmds.createNode('nurbsCurve') cmds.connectAttr(targetShape + '.local', origShape + '.create') cmds.refresh() cmds.disconnectAttr(targetShape + '.local', origShape + '.create') origObject = cmds.listRelatives(origShape, p=1)[0] origShape = cmds.parent(origShape, targetCurve) cmds.setAttr(origShape + '.io', 1) cmds.delete(origObject) sourceAttr = origShape + '.local' else: sourceAttr = cons[1] sgWobbleCurve = cmds.createNode('sgWobbleCurve2') cmds.connectAttr(sourceAttr, sgWobbleCurve + '.inputCurve') cmds.connectAttr(sgWobbleCurve + '.outputCurve', targetShape + '.create', f=1) cmds.connectAttr('time1.outTime', sgWobbleCurve + '.time') cmds.setAttr(sgWobbleCurve + '.fallOff1[0].fallOff1_Position', 0.2) cmds.setAttr(sgWobbleCurve + '.fallOff1[0].fallOff1_FloatValue', 0.0) cmds.setAttr(sgWobbleCurve + '.fallOff1[1].fallOff1_Position', 1) cmds.setAttr(sgWobbleCurve + '.fallOff1[1].fallOff1_FloatValue', 1) cmds.setAttr(sgWobbleCurve + '.timeMult1', 2)
def createClosestFollicle(trObj, meshObj): import sgBFunction_mesh import sgBFunction_dag trObjPos = cmds.xform(trObj, q=1, ws=1, t=1) u, v = sgBFunction_mesh.getUVAtPoint(trObjPos, meshObj) follicle = cmds.createNode('follicle') follicleObj = sgBFunction_dag.getTransform(follicle) cmds.connectAttr(follicle + '.ot', follicleObj + '.t') cmds.connectAttr(follicle + '.or', follicleObj + '.r') meshShape = sgBFunction_dag.getShape(meshObj) cmds.connectAttr(meshShape + '.outMesh', follicle + '.inputMesh') cmds.setAttr(follicle + '.parameterU', u) cmds.setAttr(follicle + '.parameterV', v) return follicleObj
def makeControledCurveFromJoints(sels): import sgBFunction_dag for sel in sels: children = cmds.listRelatives(sel, c=1, ad=1, f=1) children.append(sel) children.reverse() points = [[0, 0, 0] for i in range(len(children))] crv = cmds.curve(p=points, d=3) crvShape = sgBFunction_dag.getShape(crv) for i in range(len(children)): mmdc = cmds.createNode('multMatrixDecompose') cmds.connectAttr(children[i] + '.wm', mmdc + '.i[0]') cmds.connectAttr(sel + '.pim', mmdc + '.i[1]') cmds.connectAttr(mmdc + '.ot', crvShape + '.controlPoints[%d]' % i)
def makeExportObjects(exportTargets): import sgBFunction_dag import sgBFunction_connection exportMeshs = sgBFunction_dag.getChildrenMeshExists(exportTargets) for exportMesh in exportMeshs: exportMeshP = cmds.listRelatives(exportMesh, p=1, f=1)[0] cloneP = sgBFunction_dag.makeCloneObject2(exportMeshP, [':', '_'], connectionOn=True) exportMeshName = exportMesh.split('|')[-1] exportMeshOrigShape = sgBFunction_dag.getOrigShape(exportMesh, True) meshShape = cmds.createNode('mesh') cmds.connectAttr(exportMeshOrigShape + '.outMesh', meshShape + '.inMesh') meshObj = cmds.listRelatives(meshShape, p=1)[0] meshObj = cmds.rename(meshObj, exportMeshName.replace(':', '_')) meshShape = sgBFunction_dag.getShape(meshObj) meshShape = cmds.rename(meshShape, exportMeshName.replace(':', '_') + 'Shape') pivotScale = cmds.getAttr(exportMesh + '.scalePivot')[0] pivotRotate = cmds.getAttr(exportMesh + '.rotatePivot')[0] pivotScaleTr = cmds.getAttr(exportMesh + '.scalePivotTranslate')[0] pivotRotateTr = cmds.getAttr(exportMesh + '.rotatePivotTranslate')[0] cmds.setAttr(meshObj + '.scalePivot', *pivotScale) cmds.setAttr(meshObj + '.rotatePivot', *pivotRotate) cmds.setAttr(meshObj + '.scalePivotTranslate', *pivotScaleTr) cmds.setAttr(meshObj + '.rotatePivotTranslate', *pivotRotateTr) cmds.parent(meshObj, cloneP) blendShape = cmds.blendShape(exportMesh, meshObj)[0] cmds.setAttr(blendShape + '.origin', 0) cmds.setAttr(blendShape + '.w[0]', 1) cmds.sets(meshObj, e=1, forceElement='initialShadingGroup')
def setNearestPointOnCurveInfo( targetCrvs, createTransform = False ): import sgBFunction_convert import sgBFunction_dag targetCrvs = sgBFunction_convert.singleToList( targetCrvs ) infos = [] for crv in targetCrvs: crv = sgBFunction_dag.getShape( crv ) npc = cmds.createNode( 'nearestPointOnCurve' ) info = cmds.createNode( 'pointOnCurveInfo' ) cmds.connectAttr( crv+'.worldSpace[0]', npc+'.inputCurve' ) cmds.connectAttr( crv+'.worldSpace[0]', info+'.inputCurve' ) cmds.connectAttr( npc+'.parameter', info+'.parameter' ) infos.append( npc ) if createTransform: transforms = [] for info in infos: trNode = cmds.createNode( 'transform' ) fbf = cmds.createNode( 'fourByFourMatrix' ) mmdc= cmds.createNode( 'multMatrixDecompose' ) cmds.connectAttr( info+'.positionX', fbf+'.i30' ) cmds.connectAttr( info+'.positionY', fbf+'.i31' ) cmds.connectAttr( info+'.positionZ', fbf+'.i32' ) cmds.setAttr( trNode+'.dh', 1 ) cmds.connectAttr( fbf+'.output', mmdc+'.i[0]' ) cmds.connectAttr( trNode+'.pim', mmdc+'.i[1]' ) cmds.connectAttr( mmdc+'.ot', trNode+'.t' ) transforms.append( trNode ) cmds.select( transforms ) return infos
def getMeshAndIndices(targetCurve): curveShape = sgBFunction_dag.getShape(targetCurve) inputNode = curveShape crvToPointNode = None mtxFromVtxNode = None num = 0 while True: num += 1 if num >= 100: break cons = cmds.listConnections(inputNode, s=1, d=0, p=1, c=1) if not cons: return None outputCon = cons[1] node = outputCon.split('.')[0] targetNodeType = cmds.nodeType(node) if targetNodeType == 'sgCurveFromPoints': crvToPointNode = node inputNode = node continue if targetNodeType == 'sgMatrixFromVertices': mtxFromVtxNode = node break inputNode = node mesh = cmds.listConnections(mtxFromVtxNode + '.inputMesh', s=1, d=0)[0] print "crvToPointNode : ", crvToPointNode fnNode = om.MFnDependencyNode( sgBFunction_dag.getMObject(crvToPointNode)) plugInputs = fnNode.findPlug('input') indices = [] for i in range(plugInputs.numElements()): connections = om.MPlugArray() plugInputPoint = plugInputs[i].child(1) plugInputPoint.connectedTo(connections, True, False) indices.append(connections[0].logicalIndex()) return mesh, indices
def addDistanceAttribute(curve): import sgBFunction_attribute import sgBFunction_dag curveLength = getCurveLength(curve) sgBFunction_attribute.addAttr(curve, ln='initCurveLength', k=1) sgBFunction_attribute.addAttr(curve, ln='curveLength', k=1) cmds.setAttr(curve + '.initCurveLength', e=1, lock=0) cmds.setAttr(curve + '.curveLength', e=1, lock=0) cmds.setAttr(curve + '.initCurveLength', curveLength) if not cmds.listConnections( curve + '.curveLength', s=1, d=0, type='curveInfo'): curveShape = sgBFunction_dag.getShape(curve) curveInfo = cmds.createNode('curveInfo') cmds.connectAttr(curveShape + '.local', curveInfo + '.inputCurve') cmds.connectAttr(curveInfo + '.arcLength', curve + '.curveLength') cmds.setAttr(curve + '.initCurveLength', e=1, lock=1) cmds.setAttr(curve + '.curveLength', e=1, lock=1)
def getClosestParameter(targetObj, curve): import sgBFunction_dag crvShape = sgBFunction_dag.getShape(curve) dagPathTarget = sgBFunction_dag.getMDagPath(targetObj) mtxTarget = dagPathTarget.inclusiveMatrix() dagPathCurve = sgBFunction_dag.getMDagPath(crvShape) mtxCurve = dagPathCurve.inclusiveMatrix() pointTarget = om.MPoint(mtxTarget[3]) pointTarget *= mtxCurve.inverse() fnCurve = om.MFnNurbsCurve(sgBFunction_dag.getMDagPath(crvShape)) util = om.MScriptUtil() util.createFromDouble(0.0) ptrDouble = util.asDoublePtr() fnCurve.closestPoint(pointTarget, 0, ptrDouble) paramValue = om.MScriptUtil().getDouble(ptrDouble) return paramValue
def createRivetFromCurves(curves): import sgBFunction_dag loft = cmds.createNode('loft') info = cmds.createNode('pointOnSurfaceInfo') fbfm = cmds.createNode('fourByFourMatrix') mmdc = cmds.createNode('multMatrixDecompose') null = cmds.createNode('transform') vp = cmds.createNode('vectorProduct') surfShape = cmds.createNode('nurbsSurface') surfObj = sgBFunction_dag.getTransform(surfShape) for i in range(len(curves)): curve = curves[i] shape = sgBFunction_dag.getShape(curve) srcCons = cmds.listConnections(shape + '.create', p=1, c=1) if not srcCons: cmds.connectAttr(shape + '.local', loft + '.inputCurve[%d]' % i) else: cmds.connectAttr(srcCons[1], loft + '.inputCurve[%d]' % i) cmds.setAttr(vp + '.operation', 2) cmds.setAttr(info + '.top', 1) cmds.setAttr(info + '.u', 0.5) cmds.setAttr(info + '.v', 0.5) cmds.connectAttr(loft + '.outputSurface', info + '.inputSurface') cmds.connectAttr(loft + '.outputSurface', surfShape + '.create') cmds.connectAttr(info + '.nnx', fbfm + '.i00') cmds.connectAttr(info + '.nny', fbfm + '.i01') cmds.connectAttr(info + '.nnz', fbfm + '.i02') cmds.connectAttr(info + '.nvx', fbfm + '.i10') cmds.connectAttr(info + '.nvy', fbfm + '.i11') cmds.connectAttr(info + '.nvz', fbfm + '.i12') cmds.connectAttr(info + '.nnx', vp + '.input1X') cmds.connectAttr(info + '.nny', vp + '.input1Y') cmds.connectAttr(info + '.nnz', vp + '.input1Z') cmds.connectAttr(info + '.nvx', vp + '.input2X') cmds.connectAttr(info + '.nvy', vp + '.input2Y') cmds.connectAttr(info + '.nvz', vp + '.input2Z') cmds.connectAttr(vp + '.outputX', fbfm + '.i20') cmds.connectAttr(vp + '.outputY', fbfm + '.i21') cmds.connectAttr(vp + '.outputZ', fbfm + '.i22') cmds.connectAttr(info + '.px', fbfm + '.i30') cmds.connectAttr(info + '.py', fbfm + '.i31') cmds.connectAttr(info + '.pz', fbfm + '.i32') cmds.connectAttr(fbfm + '.output', mmdc + '.i[0]') cmds.connectAttr(null + '.pim', mmdc + '.i[1]') cmds.connectAttr(mmdc + '.ot', null + '.t') cmds.connectAttr(mmdc + '.or', null + '.r') cmds.addAttr(null, ln='parameterU', min=0, max=1, dv=0.5) cmds.setAttr(null + '.parameterU', e=1, k=1) cmds.addAttr(null, ln='parameterV', min=0, max=1, dv=0.5) cmds.setAttr(null + '.parameterV', e=1, k=1) cmds.connectAttr(null + '.parameterU', info + '.u') cmds.connectAttr(null + '.parameterV', info + '.v') cmds.setAttr(null + '.dh', 1) cmds.select(null) return null, surfObj
def combineSkinCluster(skinedObjs): import sgBFunction_dag numVertices = None for skinedObj in skinedObjs: objShape = sgBFunction_dag.getShape(skinedObj) fnMesh = om.MFnMesh(sgBFunction_dag.getMDagPath(objShape)) if not numVertices: numVertices = fnMesh.numVertices() else: if numVertices != fnMesh.numVertices(): cmds.error("Selected meshs not same objects") skinJoints = [] weightList = [[] for i in range(numVertices)] for skinedObj in skinedObjs: skinCluster = sgBFunction_dag.getNodeFromHistory( skinedObj, 'skinCluster') if not skinCluster: continue skinCluster = skinCluster[0] fnNode = om.MFnDependencyNode(sgBFunction_dag.getMObject(skinCluster)) plugMatrix = fnNode.findPlug('matrix') plugMatrixMaxLogicalIndex = 0 for i in range(plugMatrix.numElements()): logicalIndex = plugMatrix[i].logicalIndex() if logicalIndex > plugMatrixMaxLogicalIndex: plugMatrixMaxLogicalIndex = logicalIndex connections = om.MPlugArray() skinedJointIndices = [] origSkinedJointIndicesMap = [ -1 for i in range(plugMatrixMaxLogicalIndex + 1) ] for i in range(plugMatrix.numElements()): plugMatrix[i].connectedTo(connections, True, False) if not connections.length(): continue skinJointName = om.MFnDagNode(connections[0].node()).fullPathName() if not skinJointName in skinJoints: skinJoints.append(skinJointName) jntIndex = skinJoints.index(skinJointName) origSkinedJointIndicesMap[plugMatrix[i].logicalIndex()] = jntIndex skinedJointIndices.append(jntIndex) plugWeightList = fnNode.findPlug('weightList') for i in range(plugWeightList.numElements()): plugWeights = plugWeightList[i].child(0) for j in range(plugWeights.numElements()): logicalIndex = plugWeights[j].logicalIndex() weightValue = plugWeights[j].asFloat() jntIndex = origSkinedJointIndicesMap[logicalIndex] weightList[i].append([jntIndex, weightValue]) newMesh = cmds.createNode('mesh') srcShape = sgBFunction_dag.getShape(skinedObjs[0]) newMeshObj = sgBFunction_dag.getParent(newMesh) cmds.connectAttr(srcShape + '.outMesh', newMesh + '.inMesh') cmds.refresh() cmds.disconnectAttr(srcShape + '.outMesh', newMesh + '.inMesh') node = cmds.deformer(newMeshObj, type='skinCluster')[0] for i in range(len(skinJoints)): cmds.connectAttr(skinJoints[i] + '.wm', node + '.matrix[%d]' % i) bindPreMatrix = cmds.getAttr(skinJoints[i] + '.wim') cmds.setAttr(node + '.bindPreMatrix[%d]' % i, bindPreMatrix, type='matrix') for i in range(len(weightList)): for logicalIndex, value in weightList[i]: cmds.setAttr( node + '.weightList[%d].weights[%d]' % (i, logicalIndex), value) cmds.skinPercent(node, normalize=True)
def createControllerOnTarget(target, pivotCtlOn=True): import sgBFunction_connection import sgBFunction_dag import sgBModel_data targetPos = cmds.getAttr(target + '.wm') targetP = cmds.listRelatives(target, p=1, f=1)[0] targetName = target.split('|')[-1] ctl = cmds.circle(n='CTL_' + targetName)[0] ctlChild = cmds.createNode('transform', n='CTLChild_' + targetName) ctlChild = cmds.parent(ctlChild, ctl)[0] pivCtl = cmds.createNode('transform', n='PivCTL_' + targetName) cmds.setAttr(pivCtl + '.dh', 1) cmds.setAttr(pivCtl + '.overrideEnabled', 1) cmds.setAttr(pivCtl + '.overrideColor', 18) ctlP = cmds.group(ctl, n='P' + ctl) ctlPPiv = cmds.group(ctlP, pivCtl, n='Piv' + ctlP) cmds.xform(ctlPPiv, ws=1, matrix=targetPos) cloneObject = sgBFunction_dag.getConstrainedObject(targetP) ctlPPiv = cmds.parent(ctlPPiv, cloneObject)[0] cmds.xform(pivCtl, os=1, matrix=sgBModel_data.getDefaultMatrix()) ctl = cmds.listRelatives(ctlP, c=1, f=1)[0] sgBFunction_connection.getSourceConnection(target, ctlPPiv) for attr in [ 't', 'tx', 'ty', 'tz', 'r', 'rx', 'ry', 'rz', 's', 'sx', 'sy', 'sz', 'sh' ]: cons = cmds.listConnections(target + '.' + attr, s=1, d=0, p=1, c=1) if not cons: continue for i in range(0, len(cons), 2): cmds.disconnectAttr(cons[i + 1], cons[i]) sgBFunction_connection.constraintAll(ctlChild, target) cmds.connectAttr(pivCtl + '.t', ctlP + '.t') cmds.connectAttr(pivCtl + '.r', ctlP + '.r') cmds.connectAttr(pivCtl + '.s', ctlP + '.s') cmds.connectAttr(pivCtl + '.sh', ctlP + '.sh') mmdcCtlChild = cmds.createNode('multMatrixDecompose') cmds.connectAttr(ctlPPiv + '.wm', mmdcCtlChild + '.i[0]') cmds.connectAttr(pivCtl + '.wim', mmdcCtlChild + '.i[1]') cmds.connectAttr(mmdcCtlChild + '.ot', ctlChild + '.t') cmds.connectAttr(mmdcCtlChild + '.or', ctlChild + '.r') cmds.connectAttr(mmdcCtlChild + '.os', ctlChild + '.s') cmds.connectAttr(mmdcCtlChild + '.osh', ctlChild + '.sh') ctlShape = sgBFunction_dag.getShape(ctl) circleNode = cmds.listConnections(ctlShape + '.create', s=1, d=0)[0] mm = cmds.createNode('multMatrix') trGeo = cmds.createNode('transformGeometry') cmds.connectAttr(ctlPPiv + '.wm', mm + '.i[0]') cmds.connectAttr(pivCtl + '.wim', mm + '.i[1]') cmds.connectAttr(circleNode + '.outputCurve', trGeo + '.inputGeometry') cmds.connectAttr(mm + '.matrixSum', trGeo + '.transform') cmds.connectAttr(trGeo + '.outputGeometry', ctlShape + '.create', f=1) return ctl
def create(*args): import sgBFunction_dag reload(sgBFunction_mesh) sels = cmds.ls(sl=1) baseMesh = cmds.textField(Window_Global.fld_baseMesh, q=1, tx=1) detail = cmds.intField(Window_Global.fld_detail, q=1, v=1) base = sgBFunction_dag.getShape(baseMesh) dagPathBase = sgBFunction_dag.getMDagPath(baseMesh) oBase = sgBFunction_dag.getMObject(base) baseMtx = dagPathBase.inclusiveMatrix() fnBase = om.MFnMesh() fnBase.setObject(dagPathBase) origPointsBase = om.MPointArray() multedPointsBase = om.MPointArray() fnBase.getPoints(origPointsBase) multedPointsBase.setLength(origPointsBase.length()) for i in range(multedPointsBase.length()): multedPointsBase.set(origPointsBase[i] * baseMtx, i) fnBase.setPoints(multedPointsBase) intersector = om.MMeshIntersector() intersector.create(oBase) topJnts = [] for sel in sels: target = sgBFunction_dag.getShape(sel) dagPathMesh = sgBFunction_dag.getMDagPath(target) fnMeshTarget = om.MFnMesh(dagPathMesh) origPointsTarget = om.MPointArray() multedPointsTarget = om.MPointArray() fnMeshTarget.getPoints(origPointsTarget) targetMtx = dagPathMesh.inclusiveMatrix() multedPointsTarget.setLength(origPointsTarget.length()) for i in range(multedPointsTarget.length()): multedPointsTarget.set(origPointsTarget[i] * targetMtx, i) minDistIndex = 0 minDist = 100000.0 pointOnMesh = om.MPointOnMesh() for i in range(multedPointsTarget.length()): intersector.getClosestPoint(multedPointsTarget[i], pointOnMesh) pointClose = om.MPoint(pointOnMesh.getPoint()) dist = multedPointsTarget[i].distanceTo(pointClose) if dist < minDist: minDist = dist minDistIndex = i maxDistIndex = 0 maxDist = 0.0 for i in range(multedPointsTarget.length()): dist = multedPointsTarget[minDistIndex].distanceTo( multedPointsTarget[i]) if maxDist < dist: maxDist = dist maxDistIndex = i startCenter = om.MPoint( *cmds.xform(target + '.vtx[%d]' % minDistIndex, q=1, ws=1, t=1)) endCenter = om.MPoint( *cmds.xform(target + '.vtx[%d]' % maxDistIndex, q=1, ws=1, t=1)) jnts = sgBFunction_mesh.createJointLineFromMeshApi( dagPathMesh, startCenter, endCenter, detail) topJnts.append(jnts[0]) fnBase.setPoints(origPointsBase) cmds.select(topJnts)
def setWeightInnerPointsToTargetJoint(baseMesh, baseJoint, targetMeshs): import sgBFunction_dag baseMeshShape = sgBFunction_dag.getShape(baseMesh) dagPathBaseMesh = sgBFunction_dag.getMDagPath(baseMeshShape) mtxBaseMesh = dagPathBaseMesh.inclusiveMatrix() headIntersector = om.MMeshIntersector() headIntersector.create(dagPathBaseMesh.node()) targetMeshs = cmds.ls(sl=1) for targetMesh in targetMeshs: skinNodes = sgBFunction_dag.getNodeFromHistory(targetMesh, 'skinCluster') if not skinNodes: continue skinNode = skinNodes[0] fnSkinNode = om.MFnDependencyNode(sgBFunction_dag.getMObject(skinNode)) joints = cmds.listConnections(skinNode + '.matrix', s=1, d=0) if not baseJoint in joints: continue indexInfluence = joints.index(baseJoint) plugWeightList = fnSkinNode.findPlug('weightList') targetMeshShape = sgBFunction_dag.getShape(targetMesh) dagPathTargetMesh = sgBFunction_dag.getMDagPath(targetMeshShape) fnTargetMesh = om.MFnMesh(dagPathTargetMesh) mtxTarget = dagPathTargetMesh.inclusiveMatrix() mtxToBase = mtxTarget * mtxBaseMesh.inverse() numVertices = fnTargetMesh.numVertices() pointsTarget = om.MPointArray() fnTargetMesh.getPoints(pointsTarget) pointOnMesh = om.MPointOnMesh() targetVertices = [] for i in range(numVertices): pointLocal = pointsTarget[i] * mtxToBase headIntersector.getClosestPoint(pointLocal, pointOnMesh) point = pointOnMesh.getPoint() normal = om.MVector(pointOnMesh.getNormal()) vDir = om.MVector(pointLocal) - om.MVector(point) if vDir * normal > 0: continue plugWeights = plugWeightList[i].child(0) for j in range(plugWeights.numElements()): cmds.setAttr(plugWeights.name() + "[%d]" % j, 0) cmds.setAttr(plugWeights.name() + "[%d]" % indexInfluence, 1) targetVertices.append(targetMesh + '.vtx[%d]' % i) cmds.select(targetVertices)
def getCamControllerAndCamControled( targetCam ): import sgBFunction_dag import sgBFunction_connection import sgBFunction_attribute cloneObject = sgBFunction_dag.getConstrainedObject( targetCam ) sgBFunction_attribute.addAttr( targetCam, ln='transController', at='message' ) sgBFunction_attribute.addAttr( targetCam, ln='transControllerP', at='message' ) sgBFunction_attribute.addAttr( targetCam, ln='camControled', at='message' ) transController = cmds.listConnections( targetCam+'.transController' ) transControllerP = cmds.listConnections( targetCam+'.transControllerP' ) camControled = cmds.listConnections( targetCam+'.camControled' ) for target in [ transController, transControllerP, camControled ]: if not target: continue cmds.delete( target ) transControllerP = cmds.createNode( 'transform' ) transController = cmds.polyPlane( width=.192, height=.108, subdivisionsHeight=1, subdivisionsWidth=1 )[0] camControled = cmds.duplicate( targetCam )[0] transController = cmds.parent( transController, transControllerP )[0] cmds.setAttr( transController+'.rx', -90 ) cmds.setAttr( transController+'.s', .725, .725, .725 ) cmds.makeIdentity( transController, apply=1, t=1, r=1, s=1, n=0 ) cmds.setAttr( transController+'.overrideEnabled', 1 ) cmds.setAttr( transController+'.overrideLevelOfDetail', 1 ) cmds.setAttr( transController+'.overrideDisplayType', 2 ) cmds.setAttr( transControllerP+'.tz', -2.779 ) for attr in [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz' ]: cmds.setAttr( transControllerP+'.'+attr, e=1, lock=1 ) for attr in [ 'tz', 'rx', 'ry', 'rz' ]: cmds.setAttr( transController+'.'+attr, e=1, lock=1, k=0 ) cmds.parent( transControllerP, cloneObject ) camControledShape = sgBFunction_dag.getShape( camControled ) cmds.setAttr( camControledShape+'.displayResolution', 0 ) cmds.setAttr( camControledShape+'.displayGateMask', 0 ) cmds.connectAttr( transController+'.tx', camControledShape+'.filmTranslateH' ) cmds.connectAttr( transController+'.ty', camControledShape+'.filmTranslateV' ) multNode = cmds.createNode( 'multiplyDivide' ) luminance = cmds.createNode( 'luminance' ) multDouble = cmds.createNode( 'multDoubleLinear' ) cmds.setAttr( multNode+'.input1', 1,1,1 ) cmds.setAttr( multNode+'.op', 2 ) cmds.connectAttr( transController+'.sx', multNode+'.input2X' ) cmds.connectAttr( transController+'.sy', multNode+'.input2Y' ) cmds.connectAttr( transController+'.sz', multNode+'.input2Z' ) cmds.connectAttr( multNode+'.output', luminance+'.value' ) cmds.connectAttr( luminance+'.outValue', multDouble+'.input1' ) cmds.setAttr( multDouble+'.input2', 14 ) cmds.connectAttr( multDouble+'.output', camControledShape+'.postScale' ) sgBFunction_connection.constraintAll( targetCam, camControled ) cmds.connectAttr( transController +'.message', targetCam+'.transController' ) cmds.connectAttr( transControllerP+'.message', targetCam+'.transControllerP' ) cmds.connectAttr( camControled+'.message', targetCam+'.camControled' )
def cmdUpdatePattern(arg=0): sels = cmds.ls(sl=1) surfShape = cmds.listRelatives(sels[0], s=1, f=1)[0] nodes = cmds.listConnections(surfShape, s=0, d=1, type='sgPatternCurveOnSurface') node = nodes[0] hists = cmds.listHistory(node) delTarget = '' targetSurface = '' for hist in hists: if cmds.nodeType(hist) != 'nurbsSurface': continue if cmds.getAttr(hist + '.io'): delTarget = cmds.listRelatives(hist, p=1, f=1)[0] else: targetSurface = cmds.listRelatives(hist, p=1, f=1)[0] curves = cmds.listConnections(node + '.outputCurves') cmds.delete(curves, delTarget) import sgBFunction_dag import sgBFunction_attribute curve = sels[0] surf = targetSurface curveShape = sgBFunction_dag.getShape(curve) surfShape = sgBFunction_dag.getShape(surf) numSpansU = cmds.getAttr(surfShape + '.spansU') numSpansV = cmds.getAttr(surfShape + '.spansV') rebuildSurf = cmds.createNode('rebuildSurface') cmds.setAttr(rebuildSurf + '.keepCorners', 0) cmds.setAttr(rebuildSurf + '.spansU', numSpansU) cmds.setAttr(rebuildSurf + '.spansV', numSpansV) trGeo = cmds.createNode('transformGeometry') node = cmds.createNode('sgPatternCurveOnSurface') cmds.connectAttr(curve + '.patternSize', node + '.patternSize') cmds.connectAttr(curve + '.offsetMult', node + '.offsetMult') newSurface = cmds.createNode('nurbsSurface') cmds.setAttr(newSurface + '.io', 1) cmds.connectAttr(surfShape + '.local', rebuildSurf + '.inputSurface') cmds.connectAttr(rebuildSurf + '.outputSurface', trGeo + '.inputGeometry') cmds.connectAttr(surf + '.wm', trGeo + '.transform') cmds.connectAttr(trGeo + '.outputGeometry', newSurface + '.create') cmds.connectAttr(newSurface + '.local', node + '.surface') cmds.connectAttr(curveShape + '.local', node + '.curve') surfShape = cmds.listRelatives(curve, s=1, f=1)[0] nodes = cmds.listConnections(surfShape, s=0, d=1, type='sgPatternCurveOnSurface') outputNum = cmds.getAttr(nodes[0] + '.numOutput') for i in range(outputNum): cons = cmds.listConnections(nodes[0] + '.outputCurves[%d]' % i) if not cons: outputCurve = cmds.createNode('nurbsCurve') cmds.connectAttr(nodes[0] + '.outputCurves[%d]' % i, outputCurve + '.create')
def createRivetOnSurfacePoint(surfacePoint, firstDirection='u'): import sgBFunction_dag import sgBFunction_attribute if firstDirection.lower() == 'u': fString = 'U' sString = 'V' else: fString = 'V' sString = 'U' surfaceName, uv = surfacePoint.split('.uv') surfaceName = sgBFunction_dag.getShape(surfaceName) uvSplits = uv.split('][') uValue = float(uvSplits[0].replace('[', '')) vValue = float(uvSplits[1].replace(']', '')) pointOnSurf = cmds.createNode('pointOnSurfaceInfo') vectorNode = cmds.createNode('vectorProduct') fbfNode = cmds.createNode('fourByFourMatrix') mmdcNode = cmds.createNode('multMatrixDecompose') rivetNode = cmds.createNode('transform') cmds.setAttr(pointOnSurf + '.u', uValue) cmds.setAttr(pointOnSurf + '.v', vValue) cmds.setAttr(vectorNode + '.operation', 2) cmds.setAttr(rivetNode + '.dla', 1) cmds.setAttr(rivetNode + '.dh', 1) cmds.connectAttr(surfaceName + '.worldSpace[0]', pointOnSurf + '.inputSurface') cmds.connectAttr(pointOnSurf + '.tangent%s' % fString, vectorNode + '.input1') cmds.connectAttr(pointOnSurf + '.tangent%s' % sString, vectorNode + '.input2') cmds.connectAttr(pointOnSurf + '.tangent%sx' % fString, fbfNode + '.i00') cmds.connectAttr(pointOnSurf + '.tangent%sy' % fString, fbfNode + '.i01') cmds.connectAttr(pointOnSurf + '.tangent%sz' % fString, fbfNode + '.i02') cmds.connectAttr(pointOnSurf + '.tangent%sx' % sString, fbfNode + '.i10') cmds.connectAttr(pointOnSurf + '.tangent%sy' % sString, fbfNode + '.i11') cmds.connectAttr(pointOnSurf + '.tangent%sz' % sString, fbfNode + '.i12') cmds.connectAttr(vectorNode + '.outputX', fbfNode + '.i20') cmds.connectAttr(vectorNode + '.outputY', fbfNode + '.i21') cmds.connectAttr(vectorNode + '.outputZ', fbfNode + '.i22') cmds.connectAttr(pointOnSurf + '.positionX', fbfNode + '.i30') cmds.connectAttr(pointOnSurf + '.positionY', fbfNode + '.i31') cmds.connectAttr(pointOnSurf + '.positionZ', fbfNode + '.i32') cmds.connectAttr(fbfNode + '.output', mmdcNode + '.i[0]') cmds.connectAttr(rivetNode + '.pim', mmdcNode + '.i[1]') cmds.connectAttr(mmdcNode + '.ot', rivetNode + '.t') cmds.connectAttr(mmdcNode + '.or', rivetNode + '.r') sgBFunction_attribute.addAttr(rivetNode, ln='paramU', min=0, dv=uValue, k=1) sgBFunction_attribute.addAttr(rivetNode, ln='paramV', min=0, dv=vValue, k=1) cmds.connectAttr(rivetNode + '.paramU', pointOnSurf + '.u') cmds.connectAttr(rivetNode + '.paramV', pointOnSurf + '.v')
def getCenterCurve(curves=None): import sgBFunction_dag posList = [] bbox = om.MBoundingBox() if not curves: curves = cmds.ls(sl=1) numSpans = 0 for curve in curves: curveShape = sgBFunction_dag.getShape(curve) fnCurve = om.MFnNurbsCurve(sgBFunction_dag.getMDagPath(curveShape)) numSpans += fnCurve.numSpans() numSpans /= len(curves) posList = [[] for i in range(numSpans)] for curve in curves: curveShape = sgBFunction_dag.getShape(curve) curvePath = sgBFunction_dag.getMDagPath(curveShape) curveWorldMatrix = curvePath.inclusiveMatrix() fnCurve = om.MFnNurbsCurve(curvePath) minParam = fnCurve.findParamFromLength(0) maxParam = fnCurve.findParamFromLength(fnCurve.length()) eachParam = (float(maxParam) - float(minParam)) / numSpans bbox = om.MBoundingBox() for i in range(numSpans): eachPoint = om.MPoint() fnCurve.getPointAtParam(eachParam * i + minParam, eachPoint) posList[i].append(eachPoint * curveWorldMatrix) bbCenterList = [] for i in range(numSpans): bbox = om.MBoundingBox() for j in range(len(curves)): bbox.expand(posList[i][j]) bbCenterList.append(bbox.center()) minIndexList = [] for i in range(numSpans): minDist = 1000000.0 minIndex = 0 for j in range(len(curves)): dist = posList[i][j].distanceTo(bbCenterList[i]) if dist < minDist: minDist = dist minIndex = j minIndexList.append(minIndex) minIndexRateList = [0 for i in range(len(curves))] for i in range(numSpans): minIndexRateList[minIndexList[i]] += 1 targetCurveIndex = 0 maxIndexRate = 0 for i in range(len(minIndexRateList)): if minIndexRateList[i] > maxIndexRate: maxIndexRate = minIndexRateList[i] targetCurveIndex = i cmds.select(curves[targetCurveIndex]) return curves[minIndex]
def createUiSeparatedView(cam, width, height, indexW, indexH, sgw, sgh, sw, sh, scale, camNum, createWindow=False): uiPrefix = 'separatedViewCam_%d_' % camNum sepWidthValue = 1.0 / sgw / sw filmTransWidthValue = gWidthValues[indexW] - 1.0 / sgw - sepWidthValue filmTransWidthValues = [] for i in range(sw): filmTransWidthValue += sepWidthValue * 2 filmTransWidthValues.append(filmTransWidthValue) sepHeightValue = 1.0 / sgh / sh filmTransHeightValue = gHeightValues[ indexH] - 1.0 / sgh - sepHeightValue filmTransHeightValues = [] for i in range(sh): filmTransHeightValue += sepHeightValue * 2 filmTransHeightValues.append(filmTransHeightValue * aspectRatio) targetCams = [] tlcList = [] scaleValue = sw * sgw offsetWidth = width / sgw * indexW offsetHeight = height / sgh * indexH animationCam = cmds.duplicate(cam, n=cam + '_animation_%d_%d' % (indexW, indexH))[0] aniCamShape = sgBFunction_dag.getShape(animationCam) cmds.setAttr(aniCamShape + '.displayResolution', 0) cmds.setAttr(aniCamShape + '.displayGateMask', 0) cmds.setAttr(aniCamShape + '.postScale', scaleValue) cmds.setAttr(aniCamShape + '.filmFit', 1) sgBFunction_attribute.addAttr(animationCam, ln='mainCam', at='message') cmds.connectAttr(cam + '.aniamtionCam', animationCam + '.mainCam') cmds.setAttr(aniCamShape + '.overscan', 1) for i in range(len(filmTransHeightValues)): for j in range(len(filmTransWidthValues)): duCam = cmds.duplicate(cam, n=cam + '_translate_G_%d_%d_%02d_%02d' % (indexW, indexH, i + 1, j + 1))[0] sgBFunction_attribute.addAttr(duCam, ln='mainCam', at='message') cmds.connectAttr(cam + '.filmTranslateCams', duCam + '.mainCam') duCamShape = sgBFunction_dag.getShape(duCam) cmds.setAttr(duCamShape + '.overscan', 1) cmds.setAttr(duCamShape + '.displayResolution', 0) cmds.setAttr(duCamShape + '.displayGateMask', 0) cmds.setAttr(duCamShape + '.postScale', scaleValue) cmds.setAttr(duCamShape + '.filmFit', 1) cmds.setAttr(duCamShape + '.filmTranslateH', filmTransWidthValues[j]) cmds.setAttr(duCamShape + '.filmTranslateV', -filmTransHeightValues[i]) cuFrame = i * len(filmTransWidthValues) + j + 1 #print "frame : %02d, %5.2f, %5.2f" %( cuFrame, filmTransWidthValues[j], -filmTransHeightValues[i] ) cmds.setKeyframe(animationCam + '.filmTranslateH', t=cuFrame, v=filmTransWidthValues[j]) cmds.setKeyframe(animationCam + '.filmTranslateV', t=cuFrame, v=-filmTransHeightValues[i]) targetCams.append(duCam) tlcValue = [ int(( (filmTransHeightValues[i] - filmTransHeightValues[0]) * width / 2) * scale) + 23, int(((filmTransWidthValues[j] - filmTransWidthValues[0]) * width / 2) * scale) + 1 ] tlcList.append(tlcValue) if createWindow: for i in range(len(targetCams)): winName = uiPrefix + targetCams[i] tlc = tlcList[i] tlc[0] += top + offsetHeight * scale tlc[1] += left + offsetWidth * scale inst = sgBModel_ui.ModelEditorWindow(winName, eachResolutionWidth, eachResolutionHeight, tlc, False, camera=targetCams[i], hud=0, cameras=0, dynamics=0, ikHandles=0, nurbsCurves=0, textures=False, grid=False, da='smoothShaded') inst.create() tlc = tlcList[0] tlc[0] -= 23 inst = sgBModel_ui.ModelEditorWindow(uiPrefix + animationCam, eachResolutionWidth, eachResolutionHeight, tlc, True, False, camera=animationCam, hud=0, cameras=0, dynamics=0, ikHandles=0, nurbsCurves=0, textures=False, grid=False, da='smoothShaded') inst.create() cmds.window(inst.winName, e=1, title='WCA_%d_%d' % (indexW, indexH)) minFrame = 1 maxFrame = len(filmTransHeightValues) * len(filmTransWidthValues) cmds.playbackOptions(min=minFrame) cmds.playbackOptions(max=maxFrame) cmds.currentTime(minFrame)
def duplicateShaderToOther(first, second): import maya.mel as mel import sgBFunction_dag if not cmds.objExists(first): return None if not cmds.objExists(second): return None first = sgBFunction_dag.getTransform(first) second = sgBFunction_dag.getTransform(second) firstShape = sgBFunction_dag.getShape(first) secondShape = sgBFunction_dag.getShape(second) engines = cmds.listConnections(firstShape, type='shadingEngine') if not engines: return None engines = list(set(engines)) for engine in engines: shaders = cmds.listConnections(engine + '.surfaceShader', s=1, d=0) engine = cmds.duplicate(engine, n='du_' + engine)[0] if shaders: shader = shaders[0] cmds.hyperShade(objects=shader) selObjs = cmds.ls(sl=1, l=1) targetObjs = [] for selObj in selObjs: if selObj.find('.') != -1: trNode, components = selObj.split('.') if trNode == first: targetObjs.append(second + '.' + components) elif selObj == firstShape: targetObjs.append(secondShape) cmds.select(shader) mel.eval( 'hyperShadePanelMenuCommand("hyperShadePanel1", "duplicateShadingNetwork")' ) shader = cmds.ls(sl=1)[0] cmds.connectAttr(shader + '.outColor', engine + '.surfaceShader') aiShaders = cmds.listConnections(engine + '.aiSurfaceShader', s=1, d=0) if aiShaders: aiShader = aiShaders[0] cmds.hyperShade(objects=aiShader) selObjs = cmds.ls(sl=1, l=1) cmds.select(aiShader) mel.eval( 'hyperShadePanelMenuCommand("hyperShadePanel1", "duplicateShadingNetwork")' ) aiShader = cmds.ls(sl=1)[0] cmds.connectAttr(aiShader + '.outColor', engine + '.aiSurfaceShader') for targetObj in targetObjs: cmds.sets(targetObj, e=1, forceElement=engine)
def createVolume_byCurvesLine(self, level=6 ): import sgBFunction_dag avSpans = 0 eachMinParams = [] eachMaxParams = [] for i in range( len( self.centerCurves ) ): curve = self.centerCurves[i] curveShape = sgBFunction_dag.getShape( curve ) fnCurve = om.MFnNurbsCurve( sgBFunction_dag.getMDagPath( curveShape ) ) avSpans += fnCurve.numSpans() eachMinParam = fnCurve.findParamFromLength( 0 ) eachMaxParam = fnCurve.findParamFromLength( fnCurve.length() ) eachMinParams.append( eachMinParam ) eachMaxParams.append( eachMaxParam ) avSpans = int( avSpans / len( self.centerCurves ) ) eachParamRates = [] for i in range( len( self.centerCurves ) ): paramRate = float( eachMaxParams[i] - eachMinParams[i] ) paramRate /= (avSpans-1) eachParamRates.append( paramRate ) curvePointsList = [ [] for j in range( (level/2)*2 ) ] for i in range( avSpans ): epPoints = om.MPointArray() epPoints.setLength( len( self.centerCurves ) ) avTangent = om.MVector( 0,0,0 ) for j in range( len( self.centerCurves ) ): curveShape = sgBFunction_dag.getShape( self.centerCurves[j] ) fnCurve = om.MFnNurbsCurve( sgBFunction_dag.getMDagPath( curveShape ) ) point = om.MPoint() fnCurve.getPointAtParam( eachParamRates[j] * i + eachMinParams[j], point ) epPoints.set( point, j ) avTangent += fnCurve.tangent( eachParamRates[j] * i + eachMinParams[j] ) dataCurve = om.MFnNurbsCurveData() oCurve = dataCurve.create() fnCurveCreate = om.MFnNurbsCurve() fnCurveCreate.createWithEditPoints( epPoints, 3, 1, False, False, False, oCurve ) fnCurveCreate.setObject( oCurve ) maxParam = fnCurveCreate.findParamFromLength( fnCurveCreate.length() ) eachParam = maxParam / ( level/2 + 2 ) for j in range( level/2 ): param = eachParam * ( j+1 ) point = om.MPoint() fnCurveCreate.getPointAtParam( param, point ) vAim = fnCurveCreate.tangent( param ) vUp = avTangent vCross = vAim ^ vUp vInvCross = -vCross pointsIntersects = om.MPointArray() pointsIntersectsInv = om.MPointArray() self.fnMesh.intersect( point, vCross, pointsIntersects ) self.fnMesh.intersect( point, vInvCross, pointsIntersectsInv ) if pointsIntersects.length(): targetPoint = ( pointsIntersects[0] - om.MVector( point ) ) * 0.7 + om.MVector( point ) curvePointsList[j].append( [ targetPoint.x, targetPoint.y, targetPoint.z ] ) else: curvePointsList[j].append( [ point.x, point.y, point.z ] ) if pointsIntersectsInv.length(): targetPointInv = ( pointsIntersectsInv[0] - om.MVector( point ) ) * 0.7 + om.MVector( point ) curvePointsList[j+( level/2 )].append( [ targetPointInv.x, targetPointInv.y, targetPointInv.z ] ) else: curvePointsList[j+( level/2 )].append( [ point.x, point.y, point.z ] ) createCurves = [] for curvePoints in curvePointsList: createCurves.append( cmds.curve( ep=curvePoints ) ) return createCurves
def cmdCreatePattern(arg=0): import sgBFunction_dag import sgBFunction_attribute PatternSize = cmds.floatField(WinA_Global.ff_patternSize, q=1, v=1) OffsetMult = cmds.floatField(WinA_Global.ff_offsetMult, q=1, v=1) sels = cmds.ls(sl=1) curve = sels[0] surf = sels[1] curveShape = sgBFunction_dag.getShape(curve) surfShape = sgBFunction_dag.getShape(surf) numSpansU = cmds.getAttr(surfShape + '.spansU') numSpansV = cmds.getAttr(surfShape + '.spansV') rebuildSurf = cmds.createNode('rebuildSurface') cmds.setAttr(rebuildSurf + '.keepCorners', 0) cmds.setAttr(rebuildSurf + '.spansU', numSpansU) cmds.setAttr(rebuildSurf + '.spansV', numSpansV) trGeo = cmds.createNode('transformGeometry') node = cmds.createNode('sgPatternCurveOnSurface') sgBFunction_attribute.addAttr(curve, ln='patternSize', min=0.1, dv=PatternSize, k=1) sgBFunction_attribute.addAttr(curve, ln='offsetMult', min=0.25, dv=OffsetMult, k=1) cmds.connectAttr(curve + '.patternSize', node + '.patternSize') cmds.connectAttr(curve + '.offsetMult', node + '.offsetMult') newSurface = cmds.createNode('nurbsSurface') cmds.setAttr(newSurface + '.io', 1) cmds.connectAttr(surfShape + '.local', rebuildSurf + '.inputSurface') cmds.connectAttr(rebuildSurf + '.outputSurface', trGeo + '.inputGeometry') cmds.connectAttr(surf + '.wm', trGeo + '.transform') cmds.connectAttr(trGeo + '.outputGeometry', newSurface + '.create') cmds.connectAttr(newSurface + '.local', node + '.surface') cmds.connectAttr(curveShape + '.local', node + '.curve') surfShape = cmds.listRelatives(curve, s=1, f=1)[0] nodes = cmds.listConnections(surfShape, s=0, d=1, type='sgPatternCurveOnSurface') outputNum = cmds.getAttr(nodes[0] + '.numOutput') for i in range(outputNum): cons = cmds.listConnections(nodes[0] + '.outputCurves[%d]' % i) if not cons: outputCurve = cmds.createNode('nurbsCurve') cmds.connectAttr(nodes[0] + '.outputCurves[%d]' % i, outputCurve + '.create')
def createInCurve(surface, numCurve, paramRand=0.3, offsetRand=0.15, centerOffset=0.5): import random import sgBFunction_dag import sgBFunction_base sgBFunction_base.autoLoadPlugin("HSBVC.mll") node = cmds.createNode('volumeCurvesOnSurface') cmds.connectAttr(surface + '.wm', node + '.inputMatrix') surfaceShape = sgBFunction_dag.getShape(surface) cmds.connectAttr(surfaceShape + '.local', node + '.inputSurface') minValue, maxValue = cmds.getAttr(surfaceShape + '.minMaxRangeV')[0] if numCurve in [1, 2, 3]: paramRate = (maxValue - minValue) / numCurve else: paramRate = (maxValue - minValue) / (numCurve - 1) outputCurves = cmds.listConnections(node + '.outputCurve') if outputCurves: lenOutputCurves = len(outputCurves) if lenOutputCurves > numCurve: cmds.delete(outputCurves[numCurve - lenOutputCurves:]) if not numCurve: return None curves = [] for i in range(numCurve): addOffsetParam = random.uniform(-paramRate / 2 * paramRand, paramRate / 2 * paramRand) addOffsetCenter = random.uniform(-offsetRand, offsetRand) outputCurveCon = cmds.listConnections(node + '.outputCurve[%d]' % i) if not outputCurveCon: crvNode = cmds.createNode('nurbsCurve') crvObj = cmds.listRelatives(crvNode, p=1)[0] cmds.connectAttr(node + '.outputCurve[%d]' % i, crvNode + '.create') cmds.addAttr(crvObj, ln='paramRate', dv=paramRate * i + addOffsetParam + paramRate * 0.5) cmds.setAttr(crvObj + '.paramRate', e=1, k=1) cmds.addAttr(crvObj, ln='centerRate', dv=centerOffset + addOffsetCenter) cmds.setAttr(crvObj + '.centerRate', e=1, k=1) cmds.connectAttr(crvObj + '.paramRate', node + '.curveInfo[%d].paramRate' % i) cmds.connectAttr(crvObj + '.centerRate', node + '.curveInfo[%d].centerRate' % i) else: crvObj = outputCurveCon[0] cmds.setAttr(crvObj + '.paramRate', paramRate * i + addOffsetParam + paramRate * 0.5) cmds.setAttr(crvObj + '.centerRate', centerOffset + addOffsetCenter) crvObj = cmds.rename(crvObj, surface + '_curve_%d' % i) curves.append(crvObj) if i == numCurve - 1: if not numCurve in [2, 3]: cmds.setAttr(crvObj + '.centerRate', 0) outputLen = numCurve for i in range(outputLen): outputCons = cmds.listConnections(node + '.outputCurve[%d]' % i) if not outputCons: cmds.removeMultiInstance('%s[%d]' % (node + '.outputCurve', i)) cmds.removeMultiInstance('%s[%d]' % (node + '.curveInfo', i)) return curves
def doBake( cameraPath, minFrame, maxFrame, maya=True, mb = True, fbx=True ): import os, time, socket import sgBFunction_dag import sgBFunction_base sgBFunction_base.autoLoadPlugin( 'fbxmaya' ) removeUnknown() cameraPath = cameraPath.replace( '\\', '/' ) ##_ex_Atts = ["renderable"] _attrs = ["horizontalFilmAperture", "verticalFilmAperture", "focalLength", "lensSqueezeRatio", "fStop", "focusDistance", "shutterAngle", "centerOfInterest", "nearClipPlane", "farClipPlane", "filmFit", "filmFitOffset", "horizontalFilmOffset", "verticalFilmOffset", "shakeEnabled", "horizontalShake", "verticalShake", "shakeOverscanEnabled", "shakeOverscan", "preScale", "filmTranslateH", "filmTranslateV", "horizontalRollPivot", "verticalRollPivot", "filmRollValue", "filmRollOrder", "postScale", "depthOfField", "focusRegionScale"] if not (maya or fbx): print "AAA" return if not cmds.ls(sl=1): print "BBB" return sels = cmds.ls(sl=1) src = None src_sh = None for sel in sels: selShape = sgBFunction_dag.getShape( sel ) if cmds.nodeType( selShape ) == 'camera': src = sel src_sh = selShape if not src_sh: cmds.error( "No Camera Selected") if not (cmds.nodeType(src_sh) == "camera"): return trg = cmds.camera()[0] unit = cmds.currentUnit( q=1, time=1 ) unitDict = { 'game':15, 'film':24, 'pal':25, 'ntsc':30, 'show':48, 'palf':50, 'ntscf':60 } camName = cameraPath.split( '/' )[-1] camName += '_%d_%d_%df_bake' %( minFrame, maxFrame, unitDict[ unit ] ) trg = cmds.rename( trg, camName ) trg_sh = cmds.listRelatives(trg, s=True, f=True)[0] ##for at in cmds.listAttr(src_sh): for at in _attrs: ##if at in _ex_Atts: continue try: ##cmds.setAttr("%s.%s" % (src_sh, at), k=1) cmds.setAttr("%s.%s" % (trg_sh, at), k=1) cmds.setAttr("%s.%s" % (trg_sh, at), cmds.getAttr("%s.%s" % (src_sh, at))) cmds.connectAttr("%s.%s" % (src_sh, at), "%s.%s" % (trg_sh, at), f=1) except: pass cmds.pointConstraint(src, trg, offset=[0,0,0], weight=1) cmds.orientConstraint(src, trg, offset=[0,0,0], weight=1) cmds.setAttr(trg + ".rotateAxisX", cmds.getAttr(src + ".rotateAxisX")) cmds.setAttr(trg + ".rotateAxisY", cmds.getAttr(src + ".rotateAxisY")) cmds.setAttr(trg + ".rotateAxisZ", cmds.getAttr(src + ".rotateAxisZ")) cmds.refresh(suspend=True) try: cmds.bakeResults(trg, sm=True, t=(minFrame, maxFrame), sb=1, dic=True, pok=True, sac=False, removeBakedAttributeFromLayer=False, bakeOnOverrideLayer=False, cp=False, s=True) finally: cmds.refresh(suspend=False) cmds.refresh() cmds.delete(trg, constraints=1) try: a = cmds.listConnections(src_sh, s=0, d=1, c=1, p=1, scn=1, sh=1)[::2] b = cmds.listConnections(src_sh, s=0, d=1, c=1, p=1, scn=1, sh=1)[1::2] for i in range(len(a)): cmds.disconnectAttr(a[i], b[i]) except: pass outFN = cameraPath rntN = cmds.fileDialog2(fm=0, dir=outFN) if not rntN: return rntFN = os.path.splitext(rntN[0])[0] if maya: cmds.file(rntFN, force=1, options="v=0;", typ="mayaAscii", pr=1, es=1) if mb: cmds.file(rntFN, force=1, options="v=0;", typ="mayaBinary", pr=1, es=1) if fbx: cmds.file(rntFN, force=1, options="v=0;", typ="FBX export", pr=1, es=1) #print rnt ##setClipboardData(rnt) def showExportCamera(): if cmds.window("exportCamera", ex=1): cmds.deleteUI("exportCamera") cmds.window("exportCamera") cmds.columnLayout( adjustableColumn=True ) cmds.rowColumnLayout(numberOfColumns=2, columnWidth=[(1, 100), (2, 100)] ) mayaCB = cmds.checkBox(l="Maya", v=True) fbxCB = cmds.checkBox(l="FBX", v=True) cmds.setParent("..") #cmds.button(l="Tear off", c=lambda x:tearOffPanel()) cmds.button(l="Export", c=lambda x:doBake(cmds.checkBox(mayaCB, q=1, v=1), cmds.checkBox(fbxCB, q=1, v=1))) cmds.showWindow() showExportCamera()
def createCurveFromSelVertices_mirror(targetCurve): import sgBFunction_dag def getMeshAndIndices(targetCurve): curveShape = sgBFunction_dag.getShape(targetCurve) inputNode = curveShape crvToPointNode = None mtxFromVtxNode = None num = 0 while True: num += 1 if num >= 100: break cons = cmds.listConnections(inputNode, s=1, d=0, p=1, c=1) if not cons: return None outputCon = cons[1] node = outputCon.split('.')[0] targetNodeType = cmds.nodeType(node) if targetNodeType == 'sgCurveFromPoints': crvToPointNode = node inputNode = node continue if targetNodeType == 'sgMatrixFromVertices': mtxFromVtxNode = node break inputNode = node mesh = cmds.listConnections(mtxFromVtxNode + '.inputMesh', s=1, d=0)[0] print "crvToPointNode : ", crvToPointNode fnNode = om.MFnDependencyNode( sgBFunction_dag.getMObject(crvToPointNode)) plugInputs = fnNode.findPlug('input') indices = [] for i in range(plugInputs.numElements()): connections = om.MPlugArray() plugInputPoint = plugInputs[i].child(1) plugInputPoint.connectedTo(connections, True, False) indices.append(connections[0].logicalIndex()) return mesh, indices def createCurve(mesh, indices): vtsToCrv = cmds.createNode('sgMatrixFromVertices') pointToCrv = cmds.createNode('sgCurveFromPoints') crv = cmds.createNode('nurbsCurve') cmds.connectAttr(pointToCrv + '.outputCurve', crv + '.create') cmds.connectAttr(mesh + '.outMesh', vtsToCrv + '.inputMesh') cmds.connectAttr(mesh + '.wm', vtsToCrv + '.inputMeshMatrix') for i in range(len(indices)): cmds.setAttr(vtsToCrv + '.verticeId[%d]' % indices[i], indices[i]) cmds.connectAttr(vtsToCrv + '.outputTranslate[%d]' % indices[i], pointToCrv + '.input[%d].inputPoint' % i) return crv, pointToCrv mesh, indices = getMeshAndIndices(targetCurve) mesh = sgBFunction_dag.getShape(mesh) dagPathMesh = sgBFunction_dag.getMDagPath(mesh) intersector = om.MMeshIntersector() intersector.create(dagPathMesh.node()) meshMtx = dagPathMesh.inclusiveMatrix() meshMtxInv = dagPathMesh.inclusiveMatrixInverse() fnMesh = om.MFnMesh(dagPathMesh) pArr = om.MPointArray() fnMesh.getPoints(pArr) targetIndices = [] pointOnMesh = om.MPointOnMesh() for index in indices: worldPoint = pArr[index] * meshMtx mirrorPoint = om.MPoint(-worldPoint.x, worldPoint.y, worldPoint.z) * meshMtxInv intersector.getClosestPoint(mirrorPoint, pointOnMesh) fIndex = pointOnMesh.faceIndex() vtxIndices = om.MIntArray() fnMesh.getPolygonVertices(fIndex, vtxIndices) closeDist = 1000000.0 closeIndex = vtxIndices[0] for vtxIndex in vtxIndices: point = pArr[vtxIndex] dist = point.distanceTo(mirrorPoint) if dist < closeDist: closeDist = dist closeIndex = vtxIndex targetIndices.append(closeIndex) node = sgBFunction_dag.getNodeFromHistory(targetCurve, 'sgCurveFromPoints')[0] createType = cmds.getAttr(node + '.createType') degrees = cmds.getAttr(node + '.degrees') createdCrv, createdNode = createCurve(mesh, targetIndices) cmds.setAttr(createdNode + '.createType', createType) cmds.setAttr(createdNode + '.degrees', degrees)
def setKeyCurves(curves): import sgBFunction_dag import sgBFunction_attribute import math curves = sgBFunction_dag.getChildrenCurveExists(curves) currentFrame = str('%.2f' % cmds.currentTime(q=1)).replace('.', '_').replace( '-', 'm') frameGroup = 'keyCurveGroup_%s' % currentFrame if not cmds.objExists(frameGroup): cmds.group(em=1, n=frameGroup) sgBFunction_attribute.addAttr(frameGroup, ln='frameValue', dt='string') cmds.setAttr(frameGroup + '.frameValue', currentFrame, type='string') cmds.setAttr(frameGroup + '.overrideEnabled', 1) cmds.setAttr(frameGroup + '.overrideColor', int(math.fabs(cmds.currentTime(q=1))) % 32) keyCurves = [] for curve in curves: sgBFunction_attribute.addAttr(curve, ln='keyCurveBase', at='message') cons = cmds.listConnections(curve + '.keyCurveBase', d=1, s=0) if cons: targetCurve = None for con in cons: conP = cmds.listRelatives(con, p=1, f=1)[0] if cmds.getAttr(conP + '.frameValue') == currentFrame: targetCurve = con if targetCurve: keyCurves.append(targetCurve) continue keyCurveShape = cmds.createNode('nurbsCurve') curveShape = sgBFunction_dag.getShape(curve) cmds.connectAttr(curveShape + '.local', keyCurveShape + '.create') keyCurve = sgBFunction_dag.getTransform(keyCurveShape) curveName = curve.split('|')[-1] keyCurve = cmds.rename(keyCurve, curveName + '_' + currentFrame) keyCurves.append(keyCurve) sgBFunction_attribute.addAttr(keyCurve, ln='keyCurve', at='message') cmds.connectAttr(curve + '.keyCurveBase', keyCurve + '.keyCurve') cmds.refresh() for i in range(len(curves)): baseCurve = sgBFunction_dag.getShape(curves[i]) keyCurve = sgBFunction_dag.getShape(keyCurves[i]) if cmds.isConnected(baseCurve + '.local', keyCurve + '.create'): cmds.disconnectAttr(baseCurve + '.local', keyCurve + '.create') try: keyCurves[i] = cmds.parent(keyCurves[i], frameGroup)[0] except: continue targetKeyCurves = [] for i in range(len(curves)): baseCurve = curves[i] keyCurve = keyCurves[i] if not cmds.attributeQuery('mtxObj_forKeyCurve', node=baseCurve, ex=1): cmds.delete(keyCurve) continue mtxObj = cmds.listConnections(baseCurve + '.mtxObj_forKeyCurve', s=1, d=0) if not mtxObj: cmds.delete(keyCurve) continue targetKeyCurves.append(keyCurve) setKeyCurve(keyCurve, baseCurve, mtxObj[0]) return targetKeyCurves