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 replaceRivetMesh(source, target): sourceShape = cmds.listRelatives(source, s=1, f=1)[0] targetShape = cmds.listRelatives(target, s=1, f=1)[0] nodes = list( set( cmds.listConnections(sourceShape, d=1, s=0, type='sgMatrixFromVertices'))) import sgBFunction_dag fnSourceMesh = om.MFnMesh(sgBFunction_dag.getMDagPath(sourceShape)) fnTargetMesh = om.MFnMesh(sgBFunction_dag.getMDagPath(targetShape)) sourceMeshPoints = om.MPointArray() targetMeshPoints = om.MPointArray() fnSourceMesh.getPoints(sourceMeshPoints) fnTargetMesh.getPoints(targetMeshPoints) intersector = om.MMeshIntersector() intersector.create(fnTargetMesh.object()) for node in nodes: fnNode = om.MFnDependencyNode(sgBFunction_dag.getMObject(node)) plugVerticeId = fnNode.findPlug('verticeId') pointOnMesh = om.MPointOnMesh() for i in range(plugVerticeId.numElements()): logicalIndex = plugVerticeId[i].logicalIndex() pointSource = sourceMeshPoints[logicalIndex] intersector.getClosestPoint(pointSource, pointOnMesh) faceIndex = pointOnMesh.faceIndex() indicesVertices = om.MIntArray() fnTargetMesh.getPolygonVertices(faceIndex, indicesVertices) minDist = 100000.0 closeIndex = indicesVertices[0] for j in range(indicesVertices.length()): pointTarget = targetMeshPoints[indicesVertices[j]] dist = pointTarget.distanceTo(pointSource) if dist < minDist: minDist = dist closeIndex = indicesVertices[j] print plugVerticeId[i].name(), closeIndex cmds.setAttr(plugVerticeId[i].name(), closeIndex) cmds.connectAttr(targetShape + '.outMesh', node + '.inputMesh', f=1) cmds.connectAttr(targetShape + '.worldMatrix[0]', node + '.inputMeshMatrix', f=1)
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 replaceRivetMesh( source, target ): sourceShape = cmds.listRelatives( source, s=1, f=1 )[0] targetShape = cmds.listRelatives( target, s=1, f=1 )[0] nodes = list( set( cmds.listConnections( sourceShape, d=1, s=0, type='sgMatrixFromVertices' ) ) ) import sgBFunction_dag fnSourceMesh = om.MFnMesh( sgBFunction_dag.getMDagPath( sourceShape ) ) fnTargetMesh = om.MFnMesh( sgBFunction_dag.getMDagPath( targetShape ) ) sourceMeshPoints = om.MPointArray() targetMeshPoints = om.MPointArray() fnSourceMesh.getPoints( sourceMeshPoints ) fnTargetMesh.getPoints( targetMeshPoints ) intersector = om.MMeshIntersector() intersector.create( fnTargetMesh.object() ) for node in nodes: fnNode = om.MFnDependencyNode( sgBFunction_dag.getMObject( node ) ) plugVerticeId = fnNode.findPlug( 'verticeId' ) pointOnMesh = om.MPointOnMesh() for i in range( plugVerticeId.numElements() ): logicalIndex = plugVerticeId[i].logicalIndex() pointSource = sourceMeshPoints[ logicalIndex ] intersector.getClosestPoint( pointSource, pointOnMesh ) faceIndex = pointOnMesh.faceIndex() indicesVertices = om.MIntArray() fnTargetMesh.getPolygonVertices( faceIndex, indicesVertices ) minDist = 100000.0 closeIndex = indicesVertices[0] for j in range( indicesVertices.length() ): pointTarget = targetMeshPoints[ indicesVertices[j] ] dist = pointTarget.distanceTo( pointSource ) if dist < minDist: minDist = dist closeIndex = indicesVertices[j] print plugVerticeId[i].name(), closeIndex cmds.setAttr( plugVerticeId[i].name(), closeIndex ) cmds.connectAttr( targetShape+'.outMesh', node+'.inputMesh', f=1 ) cmds.connectAttr( targetShape+'.worldMatrix[0]', node+'.inputMeshMatrix', f=1 )
def __init__(self, meshName ): dagPathMesh = sgBFunction_dag.getMDagPath( meshName ) self.fnMesh = om.MFnMesh( dagPathMesh ) self.meshMatrix = dagPathMesh.inclusiveMatrix() self.checkPolygonMap = om.MIntArray() self.startVtxIndexMap = om.MIntArray() self.checkVertexMap = om.MIntArray() self.vtxCountPerPoly = om.MIntArray() self.vtxIndicesList = om.MIntArray() self.fnMesh.getVertices( self.vtxCountPerPoly, self.vtxIndicesList ) self.checkVertexMap.setLength( self.fnMesh.numVertices() ) self.checkPolygonMap.setLength( self.fnMesh.numPolygons() ) self.startVtxIndexMap.setLength( self.fnMesh.numPolygons() ) startVtxIndex = 0 for i in range( self.fnMesh.numVertices() ): self.checkVertexMap.set( 0, i ) for i in range( self.fnMesh.numPolygons() ): self.checkPolygonMap.set( 0, i ) self.startVtxIndexMap.set( startVtxIndex, i ) startVtxIndex += self.vtxCountPerPoly[i] self.indicesCheckedPolygon = [] self.indicesCheckedVertices = []
def getCurveLength(target): import sgBFunction_dag targetShape = sgBFunction_dag.getShape(target) fnCurve = om.MFnNurbsCurve(sgBFunction_dag.getMDagPath(targetShape)) return fnCurve.length()
def __init__(self, meshName): dagPathMesh = sgBFunction_dag.getMDagPath(meshName) self.fnMesh = om.MFnMesh(dagPathMesh) self.meshMatrix = dagPathMesh.inclusiveMatrix() self.checkPolygonMap = om.MIntArray() self.startVtxIndexMap = om.MIntArray() self.checkVertexMap = om.MIntArray() self.vtxCountPerPoly = om.MIntArray() self.vtxIndicesList = om.MIntArray() self.fnMesh.getVertices(self.vtxCountPerPoly, self.vtxIndicesList) self.checkVertexMap.setLength(self.fnMesh.numVertices()) self.checkPolygonMap.setLength(self.fnMesh.numPolygons()) self.startVtxIndexMap.setLength(self.fnMesh.numPolygons()) startVtxIndex = 0 for i in range(self.fnMesh.numVertices()): self.checkVertexMap.set(0, i) for i in range(self.fnMesh.numPolygons()): self.checkPolygonMap.set(0, i) self.startVtxIndexMap.set(startVtxIndex, i) startVtxIndex += self.vtxCountPerPoly[i] self.indicesCheckedPolygon = [] self.indicesCheckedVertices = []
def getCurveLength(target ): import sgBFunction_dag targetShape = sgBFunction_dag.getShape( target ) fnCurve = om.MFnNurbsCurve( sgBFunction_dag.getMDagPath( targetShape ) ) return fnCurve.length()
def loadSelectedStartIndices(*args): import sgBFunction_dag mesh, indices = sgBFunction_mesh.getMeshAndIndicesPoints(cmds.ls(sl=1)) cmds.textField(Window_Global.fld_targetMesh, e=1, tx=mesh) indicesStr = '' for i in indices: indicesStr += str(i) + ',' cmds.textField(Window_Global.fld_startPoints, e=1, tx=indicesStr[:-1]) fnMesh = om.MFnMesh(sgBFunction_dag.getMDagPath(mesh)) points = om.MPointArray() fnMesh.getPoints(points) bb = om.MBoundingBox() for i in range(len(indices)): bb.expand(points[indices[i]]) center = om.MPoint(bb.center()) farIndex = 0 farDist = 0.0 for i in range(points.length()): dist = center.distanceTo(points[i]) if farDist < dist: farDist = dist farIndex = i print farIndex cmds.textField(Window_Global.fld_endPoints, e=1, tx=str(farIndex))
def importAlembicData(prefix, filePath): import sgBFunction_base sgBFunction_base.autoLoadPlugin('AbcExport') beforeTopNodes = sgBFunction_dag.getTopTransformNodes() cmds.AbcImport(filePath, mode='import') afterTopNodes = sgBFunction_dag.getTopTransformNodes() fnTargets = [] for afterTopNode in afterTopNodes: if afterTopNode in beforeTopNodes: continue children = cmds.listRelatives(afterTopNode, c=1, ad=1, f=1, type='transform') if not children: children = [] children.append(afterTopNode) for child in children: fnTarget = om.MFnTransform(sgBFunction_dag.getMDagPath(child)) fnTargets.append(fnTarget) for target in fnTargets: targetName = target.name() fullName = target.fullPathName() cmds.rename(fullName, prefix + targetName)
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 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 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 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 replace(self, *args ): import sgBFunction_dag sourceName = cmds.textField( WinA_Global.fld_source, q=1, tx=1 ) targetName = cmds.textField( WinA_Global.fld_target, q=1, tx=1 ) isNamespace = cmds.checkBox( WinA_Global.chk_isNamespace, q=1, v=1 ) if not sourceName: return None if isNamespace: targets = cmds.ls() fnTargets = [] for target in targets: if target[:len(sourceName)] != sourceName: continue if cmds.attributeQuery( 'wm', node=target, ex=1 ): fnTarget = om.MFnDagNode( sgBFunction_dag.getMDagPath( target ) ) else: fnTarget = om.MFnDependencyNode( sgBFunction_dag.getMObject( target ) ) fnTargets.append( fnTarget ) for fnTarget in fnTargets: if type( fnTarget ) == type( om.MFnDagNode() ): cmds.rename( fnTarget.fullPathName(), targetName + fnTarget.name()[len(sourceName):] ) else: cmds.rename( fnTarget.name(), targetName + fnTarget.name()[len(sourceName):] ) else: targets = cmds.ls() fnTargets = [] for target in targets: if target.find( sourceName ) == -1: continue if cmds.attributeQuery( 'wm', node=target, ex=1 ): fnTarget = om.MFnDagNode( sgBFunction_dag.getMDagPath( target ) ) else: fnTarget = om.MFnDependencyNode( sgBFunction_dag.getMObject( target ) ) fnTargets.append( fnTarget ) for fnTarget in fnTargets: if type( fnTarget ) == type( om.MFnDagNode() ): cmds.rename( fnTarget.fullPathName(), fnTarget.name().replace( sourceName, targetName ) ) else: cmds.rename( fnTarget.name(), fnTarget.name().replace( sourceName, targetName ) )
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 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 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 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 create(*args): strTargetMesh = cmds.textField(Window_Global.fld_targetMesh, q=1, tx=1) strIndicesStart = cmds.textField(Window_Global.fld_startPoints, q=1, tx=1) strIndicesEnd = cmds.textField(Window_Global.fld_endPoints, q=1, tx=1) detail = cmds.intField(Window_Global.fld_detail, q=1, v=1) eStrStartIndices = strIndicesStart.split(',') eStrEndIndices = strIndicesEnd.split(',') indicesStart = [] for strIndex in eStrStartIndices: indicesStart.append(int(strIndex.strip())) indicesEnd = [] for strIndex in eStrEndIndices: indicesEnd.append(int(strIndex.strip())) import sgBFunction_dag dagPathMesh = sgBFunction_dag.getMDagPath(strTargetMesh) fnMesh = om.MFnMesh(dagPathMesh) pointsMesh = om.MPointArray() fnMesh.getPoints(pointsMesh) bbStarts = om.MBoundingBox() bbEnds = om.MBoundingBox() for index in indicesStart: bbStarts.expand(pointsMesh[index]) for index in indicesEnd: bbEnds.expand(pointsMesh[index]) startCenter = bbStarts.center() * dagPathMesh.inclusiveMatrix() endCenter = bbEnds.center() * dagPathMesh.inclusiveMatrix() sgBFunction_mesh.createJointLineFromMeshApi(dagPathMesh, startCenter, endCenter, detail)
def __init__(self, meshName): dagPathMesh = sgBFunction_dag.getMDagPath(meshName) self.fnMesh = om.MFnMesh(dagPathMesh) self.itMesh = om.MItMeshPolygon(dagPathMesh.node()) self.meshMatrix = dagPathMesh.inclusiveMatrix() self.numVertices = self.fnMesh.numVertices() self.numEdges = self.fnMesh.numEdges() self.numPolygons = self.fnMesh.numPolygons() self.points = om.MPointArray() self.fnMesh.getPoints(self.points) self.checkVertexMap = om.MIntArray() self.checkPolygonMap = om.MIntArray() self.checkVertexMap.setLength(self.numVertices) for i in range(self.numVertices): self.checkVertexMap.set(0, i) self.checkPolygonMap.setLength(self.numPolygons) for i in range(self.numPolygons): self.checkPolygonMap.set(0, i) self.centerVtxExistsEdges = [0 for i in range(self.numEdges)] self.centerVtxPointPerEdges = [ om.MPoint() for i in range(self.numEdges) ] self.edgesPerPolygon = [ om.MIntArray() for i in range(self.numPolygons) ] while not self.itMesh.isDone(): self.itMesh.getEdges(self.edgesPerPolygon[self.itMesh.index()]) self.itMesh.next() self.renumberedVerticesMap = om.MIntArray() self.renumberedVerticesMap.setLength(self.numVertices) self.addVtxCurrentNum = 0 self.addVerticesIndices = om.MIntArray() self.addVerticesPoints = om.MPointArray() self.addVerticesCounts = om.MIntArray() self.addVerticesIndices = om.MIntArray()
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 __init__(self, meshName ): dagPathMesh = sgBFunction_dag.getMDagPath( meshName ) self.fnMesh = om.MFnMesh( dagPathMesh ) self.itMesh = om.MItMeshPolygon( dagPathMesh.node() ) self.meshMatrix = dagPathMesh.inclusiveMatrix() self.numVertices = self.fnMesh.numVertices() self.numEdges = self.fnMesh.numEdges() self.numPolygons = self.fnMesh.numPolygons() self.points = om.MPointArray() self.fnMesh.getPoints( self.points ) self.checkVertexMap = om.MIntArray() self.checkPolygonMap = om.MIntArray() self.checkVertexMap.setLength( self.numVertices ) for i in range( self.numVertices ): self.checkVertexMap.set( 0, i ) self.checkPolygonMap.setLength( self.numPolygons ) for i in range( self.numPolygons ): self.checkPolygonMap.set( 0, i ) self.centerVtxExistsEdges = [ 0 for i in range( self.numEdges ) ] self.centerVtxPointPerEdges = [ om.MPoint() for i in range( self.numEdges ) ] self.edgesPerPolygon = [ om.MIntArray() for i in range( self.numPolygons ) ] while not self.itMesh.isDone(): self.itMesh.getEdges( self.edgesPerPolygon[self.itMesh.index()] ) self.itMesh.next() self.renumberedVerticesMap = om.MIntArray() self.renumberedVerticesMap.setLength( self.numVertices ) self.addVtxCurrentNum = 0 self.addVerticesIndices = om.MIntArray() self.addVerticesPoints = om.MPointArray() self.addVerticesCounts = om.MIntArray() self.addVerticesIndices = om.MIntArray()
def importAlembicData( prefix, filePath ): import sgBFunction_base sgBFunction_base.autoLoadPlugin( 'AbcExport' ) beforeTopNodes = sgBFunction_dag.getTopTransformNodes() cmds.AbcImport( filePath, mode='import' ) afterTopNodes = sgBFunction_dag.getTopTransformNodes() fnTargets = [] for afterTopNode in afterTopNodes: if afterTopNode in beforeTopNodes: continue children = cmds.listRelatives( afterTopNode, c=1, ad=1, f=1, type='transform' ) if not children: children = [] children.append( afterTopNode ) for child in children: fnTarget = om.MFnTransform( sgBFunction_dag.getMDagPath( child ) ) fnTargets.append( fnTarget ) for target in fnTargets: targetName = target.name() fullName = target.fullPathName() cmds.rename( fullName, prefix + targetName )
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 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 createRivetFromVertex_mirror( rivetObj ): import sgBFunction_dag import sgBFunction_base import sgBFunction_convert sgBFunction_base.autoLoadPlugin( 'sgRigAddition' ) 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 cons = cmds.listConnections( rivetObj, s=1, d=0, type='sgMatrixFromVertices', p=1, c=1 ) if not cons: return None node, attr = cons[1].split( '.' ) vtxNum = int( attr.split( '[' )[1].replace( ']', '' ) ) mesh = cmds.listConnections( node, s=1, d=0, type='mesh', shapes=1 ) if not mesh: return None mesh = mesh[0] fnMesh = om.MFnMesh( sgBFunction_dag.getMDagPath( mesh ) ) intersector = om.MMeshIntersector() intersector.create( fnMesh.object() ) pointArr = om.MPointArray() fnMesh.getPoints( pointArr ) pointMirror = om.MPoint( -pointArr[ vtxNum ].x, pointArr[ vtxNum ].y, pointArr[ vtxNum ].z ) pointOnMesh = om.MPointOnMesh() intersector.getClosestPoint( pointMirror, pointOnMesh ) faceIndex = pointOnMesh.faceIndex() vertices = om.MIntArray() fnMesh.getPolygonVertices( faceIndex, vertices ) closeIndex = 0 closeDist = 1000000.0 for i in range( vertices.length() ): dist = pointArr[ vertices[i] ].distanceTo( pointMirror ) if closeDist > dist: closeDist = dist closeIndex = vertices[i] cmds.setAttr( node+'.verticeId[%d]' % closeIndex, closeIndex ) rivetObjName = rivetObj.split( '|' )[-1] rivetObjName = rivetObjName.replace( str( vtxNum ), str( closeIndex ) ) newObject = cmds.createNode( 'transform', n= sgBFunction_convert.convertSide( rivetObjName ) ) cmds.setAttr( newObject+'.dh', 1 ) cmds.setAttr( newObject+'.inheritsTransform', 0 ) cmds.connectAttr( node+'.outputTranslate[%d]' % closeIndex, newObject+'.t' )
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 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 assignReferenceShader( infoPath, objectNamespace, shaderNamespace=None ): import cPickle import maya.OpenMaya as om import copy import sgBModel_data f = open( infoPath, 'r' ) refShaderInfos, userDefinedMeshAttrInfos = cPickle.load( f ) f.close() if not shaderNamespace: shaderNamespace = copy.copy( objectNamespace ) objectNamespace = objectNamespace.replace( ':', '_' ) shaderNamespace = shaderNamespace.replace( ':', '_' ) objNs = copy.copy( objectNamespace ) shaderNs = copy.copy( shaderNamespace ) if objNs: objNs +='_' if shaderNs: shaderNs +=':' existingPaths = [] for data in refShaderInfos: refPath = data.referencePath.replace( '\\', '/' ) for ref in cmds.ls( type='reference' ): existingPath = cmds.referenceQuery( ref, filename=1 ) if not existingPath in existingPaths: existingPaths.append( existingPath ) if not refPath in existingPaths: if not shaderNamespace : cmds.file( refPath, r=1, ignoreVersion=True, gl=1, mergeNamespacesOnClash = False, namespace=':', options="v=0;" ) else: cmds.file( refPath, r=1, ignoreVersion=True, gl=1, mergeNamespacesOnClash = False, namespace=shaderNamespace, options="v=0;" ) print "referenced path : ", refPath shaderName = data.shaderName disName = data.displaceName volumeName = data.volumeName targets = data.assignedTargets shaderName = shaderNs + shaderName if disName: disName = shaderNs + disName if volumeName: volumeName = shaderNs + volumeName for shape, indices in targets: if not cmds.objExists( objNs+shape ): continue dagPath = sgBFunction_dag.getMDagPath( objNs+shape ) if indices: intArr = om.MIntArray() intArr.setLength( len( indices ) ) for i in range( len( indices ) ): intArr[i] = indices[i] singleIndexedComp = om.MFnSingleIndexedComponent() mObject = singleIndexedComp.create( om.MFn.kMeshPolygonComponent ) singleIndexedComp.addElements( intArr ) cmds.select( d=1 ) om.MGlobal.select( dagPath, mObject ) cmds.hyperShade( assign=shaderName ) om.MGlobal.unselect( dagPath, mObject ) else: cmds.select( objNs+shape ) cmds.hyperShade( assign=shaderName ) cmds.select( d=1 ) shadingEngine = getShadingEngine( shaderName ) if disName: cmds.connectAttr( disName + '.displacement', shadingEngine + '.displacementShader' ) import sgBFunction_attribute for mesh, udAttrInfo in userDefinedMeshAttrInfos: targetMesh = objNs.replace( ':', '_' ) + mesh if not cmds.objExists( targetMesh ): continue sgBFunction_attribute.setUdAttrInfo( udAttrInfo, targetMesh )
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 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 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 createRivetBasedOnSkinWeights( selectedObjs ): import sgBFunction_convert import sgBFunction_mesh import sgBFunction_dag import sgBFunction_skinCluster import maya.OpenMaya as om def getJointMultMatrix( jnt, mtxBindPre ): cons = cmds.listConnections( jnt+'.wm', type='multMatrix' ) if cons: for con in cons: if cmds.attributeQuery( 'skinWeightInfluenceMatrix', node=con, ex=1 ): if mtxBindPre == cmds.getAttr( con+'.i[0]' ): return con mmtxNode = cmds.createNode( 'multMatrix' ) cmds.setAttr( mmtxNode+'.i[0]', mtxBindPre, type='matrix' ) cmds.connectAttr( jnt+'.wm', mmtxNode+'.i[1]' ) cmds.addAttr( mmtxNode, ln='skinWeightInfluenceMatrix', at='message' ) return mmtxNode mesh, vtxIndices = sgBFunction_mesh.getMeshAndIndicesPoints( selectedObjs ) skinClusterNode = sgBFunction_dag.getNodeFromHistory( mesh, 'skinCluster' ) if not skinClusterNode: return None skinClusterNode = skinClusterNode[0] influenceAndWeightList, phygicalMap = sgBFunction_skinCluster.getInfluenceAndWeightList( mesh, vtxIndices ) meshMatrix = sgBFunction_dag.getMDagPath( mesh ).inclusiveMatrix() meshPoints = sgBFunction_mesh.getLocalPoints( mesh ) plugMatrix = sgBFunction_skinCluster.getPlugMatrix( mesh ) plugBindPre = sgBFunction_skinCluster.getPlugBindPre( mesh ) BB = om.MBoundingBox() wtAddMtx = cmds.createNode( 'wtAddMatrix' ) mtxPlugIndidcesAndWeights = {} allWeights = 0.0 for i in vtxIndices: influenceList, weights = influenceAndWeightList[ phygicalMap[i] ] for j in range( len( influenceList ) ): mtxPlugIndex = influenceList[j] if mtxPlugIndex in mtxPlugIndidcesAndWeights.keys(): mtxPlugIndidcesAndWeights[mtxPlugIndex] += weights[j] else: mtxPlugIndidcesAndWeights.update( {mtxPlugIndex:weights[j]} ) allWeights += weights[j] BB.expand( meshPoints[i] ) worldPoint = BB.center()*meshMatrix items = mtxPlugIndidcesAndWeights.items() for i in range( len( items ) ): influence, weight = items[i] plugMatrixElement = plugMatrix.elementByLogicalIndex( influence ) plugBindPreElement = plugBindPre.elementByLogicalIndex( influence ) jnt = cmds.listConnections( plugMatrixElement.name(), s=1, d=0, type='joint' )[0] mtxBindPre = cmds.getAttr( plugBindPreElement.name() ) mmtxNode = getJointMultMatrix( jnt, mtxBindPre ) cmds.connectAttr( mmtxNode+'.o', wtAddMtx+'.i[%d].m' % i ) cmds.setAttr( wtAddMtx+'.i[%d].w' % i, weight/allWeights ) origObj = cmds.createNode( 'transform', n='OrigObject' ) destObj = cmds.createNode( 'transform', n='destObject' ) cmds.setAttr( destObj+'.dh' , 1 ) cmds.setAttr( destObj+'.dla', 1 ) mmNode = cmds.createNode( 'multMatrix' ) dcmp = cmds.createNode( 'decomposeMatrix' ) mtxWtAdd = cmds.getAttr( wtAddMtx+'.o' ) cmds.connectAttr( origObj+'.wm', mmNode+'.i[0]' ) cmds.connectAttr( wtAddMtx+'.o', mmNode+'.i[1]' ) cmds.connectAttr( destObj+'.pim', mmNode+'.i[2]' ) cmds.connectAttr( mmNode+'.o', dcmp+'.imat' ) cmds.connectAttr( dcmp+'.ot', destObj+'.t' ) cmds.connectAttr( dcmp+'.or', destObj+'.r' ) mmtxWtAdd = sgBFunction_convert.convertMatrixToMMatrix( mtxWtAdd ) worldPoint *= mmtxWtAdd.inverse() cmds.setAttr( origObj+'.t', worldPoint.x, worldPoint.y, worldPoint.z )
def createRivetFromVertex_mirror(rivetObj): import sgBFunction_dag import sgBFunction_base import sgBFunction_convert sgBFunction_base.autoLoadPlugin('sgRigAddition') 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 cons = cmds.listConnections(rivetObj, s=1, d=0, type='sgMatrixFromVertices', p=1, c=1) if not cons: return None node, attr = cons[1].split('.') vtxNum = int(attr.split('[')[1].replace(']', '')) mesh = cmds.listConnections(node, s=1, d=0, type='mesh', shapes=1) if not mesh: return None mesh = mesh[0] fnMesh = om.MFnMesh(sgBFunction_dag.getMDagPath(mesh)) intersector = om.MMeshIntersector() intersector.create(fnMesh.object()) pointArr = om.MPointArray() fnMesh.getPoints(pointArr) pointMirror = om.MPoint(-pointArr[vtxNum].x, pointArr[vtxNum].y, pointArr[vtxNum].z) pointOnMesh = om.MPointOnMesh() intersector.getClosestPoint(pointMirror, pointOnMesh) faceIndex = pointOnMesh.faceIndex() vertices = om.MIntArray() fnMesh.getPolygonVertices(faceIndex, vertices) closeIndex = 0 closeDist = 1000000.0 for i in range(vertices.length()): dist = pointArr[vertices[i]].distanceTo(pointMirror) if closeDist > dist: closeDist = dist closeIndex = vertices[i] cmds.setAttr(node + '.verticeId[%d]' % closeIndex, closeIndex) rivetObjName = rivetObj.split('|')[-1] rivetObjName = rivetObjName.replace(str(vtxNum), str(closeIndex)) newObject = cmds.createNode( 'transform', n=sgBFunction_convert.convertSide(rivetObjName)) cmds.setAttr(newObject + '.dh', 1) cmds.setAttr(newObject + '.inheritsTransform', 0) cmds.connectAttr(node + '.outputTranslate[%d]' % closeIndex, newObject + '.t')
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 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 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)