def unlockNormal(self): cont = '' nodes = cmds.ls(type=('mesh', 'nurbsSurface')) if nodes != []: cmds.polyNormalPerVertex(nodes, ufn=1) cont = u'Unlock Normal 节点: %s\n' % len(nodes) return cont
def convert_edge_lock(): sel = cmds.ls(sl=True, l=True) meshes = common.search_polygon_mesh(sel, serchChildeNode=False) if not meshes: return for mesh in meshes: d_mesh = cmds.duplicate(mesh, rr=True)[0] modeling.setSoftEdge(mesh, angle=120) cmds.transferAttributes( d_mesh, mesh, flipUVs=0, transferPositions=0, transferUVs=0, sourceUvSpace="map1", searchMethod=3, transferNormals=1, transferColors=0, targetUvSpace="map1", colorBorders=1, sampleSpace=5, ) freeze.main(mesh) cmds.polyNormalPerVertex(mesh, ufn=True) cmds.delete(d_mesh) cmds.select(meshes)
def face_normal(face): polyface = mc.polyListComponentConversion(face, tvf=True) xes = mc.polyNormalPerVertex(polyface, q=True, x=True) yes = mc.polyNormalPerVertex(polyface, q=True, y=True) zes = mc.polyNormalPerVertex(polyface, q=True, z=True) divisor = 1.0 / len(xes) return sum(xes) * divisor, sum(yes) * divisor, sum(zes) * divisor
def HardedgeNormals(self): henselVerArray = cmds.ls( selection=True, fl=True ) if not henselVerArray: pass print "nothing selected" return if self.selectlive: # print"test: sel islive in HardedgeNormals" self.selectlive = False # print "self.selectlive", self.selectlive cmds.polyNormalPerVertex(ufn=True) cmds.select(cmds.polyListComponentConversion( henselVerArray, te=True )) cmds.polySoftEdge( a=self.NormalAngle.value() ) # cmds.polyNormalPerVertex(cmds.polyListComponentConversion( selVerArray, tv=True ),ufn=True) cmds.select(henselVerArray) self.VecOriginlist = nrmedittool.BuildVecOrigin() self.SliderIntensity.setValue(0) self.selectlive = True return else: # print"test: sel is not live in HardedgeNormals" cmds.polyNormalPerVertex(ufn=True) cmds.select(cmds.polyListComponentConversion( henselVerArray, te=True )) cmds.polySoftEdge( a=self.NormalAngle.value() ) cmds.select(henselVerArray) self.VecOriginlist = nrmedittool.BuildVecOrigin() return
def shell_border_edges_to_hard(): """ Sets uv border edges on a mesh has hard, and everythign else as soft. """ objList = cmds.ls(sl=True, o=True) finalBorder = [] for subObj in objList: cmds.select(subObj, r=True) cmds.polyNormalPerVertex(ufn=True) cmds.polySoftEdge(subObj, a=180, ch=1) cmds.select(subObj + '.map[*]', r=True) polySelectBorderShell(borderOnly=True) uvBorder = cmds.polyListComponentConversion(te=True, internal=True) uvBorder = cmds.ls(uvBorder, fl=True) for curEdge in uvBorder: edgeUVs = cmds.polyListComponentConversion(curEdge, tuv=True) edgeUVs = cmds.ls(edgeUVs, fl=True) if len(edgeUVs) > 2: finalBorder.append(curEdge) cmds.polySoftEdge(finalBorder, a=0, ch=1) cmds.select(objList)
def alignToRef(self): if len(self.refVerts) == 0: cmds.error("Reference vertexes are not defined. Please define ref first.") selection = cmds.ls(sl=True, long=True) cmds.select(cmds.polyListComponentConversion(toVertex=True), replace=True) verts = cmds.filterExpand(sm=31, expand=True, fullPath=True) shape = str(self.refVerts[0]).split(".")[0] refTransform = cmds.listRelatives(shape, parent=True, path=True, fullPath=True)[0] shape = str(verts[0]).split(".")[0] objTransform = cmds.listRelatives(shape, parent=True, path=True, fullPath=True)[0] objTransformMatrixInverse = getTransformMatrix(objTransform).inverse() refRot = cmds.xform(refTransform, q=True, ws=True, ro=True) refAngle = om.MEulerRotation(math.radians(refRot[0]), math.radians(refRot[1]), math.radians(refRot[2]), om.MEulerRotation.kXYZ) for vert in verts: refVertIndex = self.findNearestVertIndex(vert) refNormal = cmds.polyNormalPerVertex(self.refVerts[refVertIndex], q=True, xyz=True) vec = om.MVector(refNormal[0], refNormal[1], refNormal[2]) refNormal = vec.rotateBy(refAngle) normalVector = om.MVector(refNormal[0], refNormal[1], refNormal[2]) newVector = normalVector * objTransformMatrixInverse # Assuming normals are equal for all triangles at this vert, and using the first triple. cmds.polyNormalPerVertex(vert, xyz=(newVector[0], newVector[1], newVector[2])) cmds.select(selection, r=True)
def allign(vtx1, vtx2, local_y_flip=False): """Alligns the normal of vtx1 to the normal of vtx2 Args: vtx1 (str): name of the source vertex vtx2 (str): name of the destination vertex local_y_flip (bool): whether to flip source object along it's Y axis once alligned Returns: None """ # Matching rotation of face normal obj_name = vtx1.split(".")[0] vec1 = cmds.polyNormalPerVertex(vtx1, query=True, xyz=True)[:3] vec2 = cmds.polyNormalPerVertex(vtx2, query=True, xyz=True)[:3] rotation_matrix = get_rotation_matrix(vec1, vec2) euler_radians = rotation_matrix_to_euler(rotation_matrix) r_x, r_y, r_z = [math.degrees(i) for i in euler_radians] cmds.rotate(r_x, r_y, r_z, [obj_name]) if local_y_flip: cmds.scale(1, -1, 1, [obj_name], os=True, r=True) # Matching face position v1_x, v1_y, v1_z = get_position(vtx1) v2_x, v2_y, v2_z = get_position(vtx2) cmds.move(v1_x, v1_y, v1_z, "{}.scalePivot".format(obj_name), "{}.rotatePivot".format(obj_name), rpr=True) cmds.move(v2_x, v2_y, v2_z, [obj_name], rpr=True, ws=True)
def initGeometry(self): selection = m.ls(sl=True) meshes = m.ls( selection=True, long=True, dagObjects=True, allPaths=True, type='mesh', noIntermediate=True ) if meshes: for mesh in meshes: transform = com.getParent(mesh) if transform: self.backupers.append(backuper.Backuper(mesh, transform)) m.polyNormalPerVertex(mesh, ufn=True) m.polySoftEdge(transform, a=180, ch=False) geomProcessor = geom_processor.GeomProcessor(mesh) geomProcessor.params = Parameters self.processors.append(geomProcessor) else: pm.confirmDialog( title='Error', message='Invalid selection. Select at least one mesh.', button=['OK'], defaultButton='OK', icon='critical' ) return m.select(selection, r=True)
def initGeometry(self): selection = m.ls(sl=True) meshes = m.ls(selection=True, long=True, dagObjects=True, allPaths=True, type='mesh', noIntermediate=True) if meshes: for mesh in meshes: transform = com.getParent(mesh) if transform: self.backupers.append(backuper.Backuper(mesh, transform)) m.polyNormalPerVertex(mesh, ufn=True) m.polySoftEdge(transform, a=180, ch=False) geomProcessor = geom_processor.GeomProcessor(mesh) geomProcessor.params = Parameters self.processors.append(geomProcessor) else: pm.confirmDialog( title='Error', message='Invalid selection. Select at least one mesh.', button=['OK'], defaultButton='OK', icon='critical') return m.select(selection, r=True)
def uvShellHardEdges(): ''' Sets uv border edges on a mesh has hard, and everythign else as soft. ''' objList = cmds.ls(sl=True, o=True) finalBorder = [] for subObj in objList: cmds.select(subObj, r=True) cmds.polyNormalPerVertex(ufn=True) cmds.polySoftEdge(subObj, a=180, ch=1) cmds.select(subObj + '.map[*]', r=True) polySelectBorderShell(borderOnly=True) uvBorder = cmds.polyListComponentConversion(te=True, internal=True) uvBorder = cmds.ls(uvBorder, fl=True) for curEdge in uvBorder: edgeUVs = cmds.polyListComponentConversion(curEdge, tuv=True) edgeUVs = cmds.ls(edgeUVs, fl=True) if len(edgeUVs) > 2: finalBorder.append(curEdge) cmds.polySoftEdge(finalBorder, a=0, ch=1) cmds.select(objList)
def run(): #get selected edgeloop edgeLoop = cmds.ls(selection=True) #get verticles in the edge loop vertLoop = cmds.polyListComponentConversion(edgeLoop, fromEdge=True, toVertex=True) #sort individual verticles into a list vertLoop = cmds.ls(vertLoop, flatten=True) #open undo chunk so entire operation is a single action cmds.undoInfo(openChunk = True) #soften the mesh normals mesh = cmds.listRelatives(parent=1) cmds.polySoftEdge(mesh, angle=180) #run on each vertex on the edgeloop for vert in vertLoop: #unlock the normal of the vertex cmds.polyNormalPerVertex(vert, unFreezeNormal=True) #get the normals of the vertex on the loop vertNormals = list(cmds.polyNormalPerVertex(vert, query=True, xyz=True)) #get only the first three vectors vertNormals = vertNormals[:3] # select the neighboring verticles using the declared function below vertNeighbors(vert, vertLoop) #set their normal angle to match the vertex on the loop cmds.polyNormalPerVertex(xyz=vertNormals) #reselect the edge loops cmds.select(edgeLoop) #close undo chunk, operation is done cmds.undoInfo(closeChunk = True)
def fix_invalid(cls, instance): """Unlocks all normals on the meshes in this instance.""" from maya import cmds invalid = cls.get_invalid(instance) for mesh in invalid: cmds.polyNormalPerVertex(mesh, unFreezeNormal=True) """
def normal_lock(): '''法线锁定 ''' meshs = cmds.ls(type="mesh", io=0) lockmesh = [] if meshs: for _mesh in meshs: cmds.polyNormalPerVertex(_mesh, ufn=1)
def softEdgeSelection(): """ unlock normals and soft edge """ sel = cmds.ls(sl=True) for node in sel: cmds.polyNormalPerVertex(node, ufn=True) cmds.polySoftEdge(node, angle=normalAngle)
def testStaticMeshPolyNormals(self): # create a polygon cube polyName = 'polyCube' polyShapeName = 'polyCubeShape' MayaCmds.polyCube(sx=1, sy=1, sz=1, name=polyName, constructionHistory=False) # add the necessary props MayaCmds.select(polyShapeName) MayaCmds.addAttr(longName='SubDivisionMesh', attributeType='bool', defaultValue=False) MayaCmds.addAttr(longName='noNormals', attributeType='bool', defaultValue=False) MayaCmds.addAttr(longName='flipNormals', attributeType='bool', defaultValue=False) # tweek some normals MayaCmds.select(polyName + '.vtxFace[2][1]', replace=True) MayaCmds.polyNormalPerVertex(xyz=(0.707107, 0.707107, 0)) MayaCmds.select(polyName + '.vtxFace[7][4]', replace=True) MayaCmds.polyNormalPerVertex(xyz=(-0.707107, 0.707107, 0)) # write to file self.__files.append(util.expandFileName('staticPolyNormalsTest.abc')) MayaCmds.AbcExport(j='-root %s -f %s' % (polyName, self.__files[-1])) # read back from file MayaCmds.AbcImport(self.__files[-1], mode='import') self.failIf( MayaCmds.listAttr('polyCube1|polyCubeShape').count('noNormals') != 0) # make sure the normals are the same shapeObj = getObjFromName('polyCube1|polyCubeShape') fnMesh = OpenMaya.MFnMesh(shapeObj) numFaces = fnMesh.numPolygons() for faceIndex in range(0, numFaces): vertexList = OpenMaya.MIntArray() fnMesh.getPolygonVertices(faceIndex, vertexList) numVertices = vertexList.length() for v in range(0, numVertices): vertexIndex = vertexList[v] normal = OpenMaya.MVector() fnMesh.getFaceVertexNormal(faceIndex, vertexIndex, normal) vtxFaceAttrName = '.vtxFace[%d][%d]' % (vertexIndex, faceIndex) MayaCmds.select(polyName + vtxFaceAttrName, replace=True) oNormal = MayaCmds.polyNormalPerVertex(query=True, xyz=True) self.failUnlessAlmostEqual(normal[0], oNormal[0], 4) self.failUnlessAlmostEqual(normal[1], oNormal[1], 4) self.failUnlessAlmostEqual(normal[2], oNormal[2], 4)
def unlockAndHarden(): """ comverts selected components to vertices, unlocks and harden """ if cmds.ls(sl=True): newSel = cmds.polyListComponentConversion(ff=True, fe=True, fuv=True, fvf=True, tv=True) cmds.select(newSel) cmds.polyNormalPerVertex(ufn=True) cmds.polySoftEdge(angle=0, ch=False)
def setvtxtoorigin(self): vtxFaceCountFloat = len(self.OriginVectorDic) - 1 ovdindex = self.OriginVectorDic['index'] if not ovdindex: pass else: for x in range(0,vtxFaceCountFloat): currentvtxFace = ovdindex[x] currentvtxOVal = self.OriginVectorDic[ovdindex[x]] cmds.polyNormalPerVertex(currentvtxFace, xyz = currentvtxOVal)
def cp_vertex_normal(): """ Select your source vertex normal and destination, then run the script. """ vsel = cmds.ls(sl=True, fl=True) src = vsel[0] dest = vsel[1] srcNorm = cmds.polyNormalPerVertex(vsel[0], q=True, xyz=True) cmds.polyNormalPerVertex(dest, xyz=(srcNorm[0], srcNorm[1], srcNorm[2]), edit=True)
def toAlembic(parameters, arguments): """ Converts an Obj file to Alembic file. :param parameters: Command line parameters. :type parameters: object :param arguments: Command line arguments. :type arguments: object :return: Definition success. :rtype: bool """ inputFile = parameters.inputFile if inputFile is None: sys.stderr.write("!> {0} | No input file provided!\n".format(inspect.getmodulename(__file__))) return if not os.path.exists(inputFile): sys.stderr.write("!> {0} | '{1}' file doesn't exists'!\n".format(inspect.getmodulename(__file__), inputFile)) return outputFile = os.path.abspath(parameters.outputFile if parameters.outputFile else re.sub(r"\.\w+$", ".abc", inputFile)) exportAll = parameters.exportAll frameRange = parameters.frameRange try: frameIn, frameOut = frameRange.split("-") except ValueError: sys.stderr.write("!> {0} | The frame range format could not be determined!\n".format(inspect.getmodulename(__file__))) return not cmds.pluginInfo("AbcExport", q=True, loaded=True) and cmds.loadPlugin("AbcExport") cmds.file(inputFile, o=True) # Processing ".obj" file normals. if re.search(r"\.obj$", inputFile, flags=re.IGNORECASE): for mesh in cmds.ls(type="mesh", long=True): cmds.polyNormalPerVertex(mesh, ufn=True) cmds.polySoftEdge(mesh, a=180, ch=False) if exportAll: jobCommand = "-frameRange {0} {1} -uvWrite -file {2}".format(frameIn, frameOut, outputFile) else: rootNodes = list(set([getRoot(mesh) for mesh in cmds.ls(type="mesh", long=True)])) rootFlags = " ".join(["-root {0}".format(rootNode) for rootNode in rootNodes]) jobCommand = "-frameRange {0} {1} -uvWrite {2} -file {3}".format(frameIn, frameOut, rootFlags, outputFile) sys.stderr.write("{0} | Exporting to 'Alembic' with following job command: '{1}'\n".format(inspect.getmodulename(__file__), jobCommand)) cmds.AbcExport(j=jobCommand) return True
def unlockNormals(meshList=[]): ''' ''' # Check meshList meshList = getMeshList(meshList) if not meshList: return [] # Unlock Normals for mesh in meshList: mc.polyNormalPerVertex(mesh, ufn=True) # Return result return meshList
def testStaticMeshPolyNormals(self): # create a polygon cube polyName = 'polyCube' polyShapeName = 'polyCubeShape' MayaCmds.polyCube( sx=1, sy=1, sz=1, name=polyName, constructionHistory=False) # add the necessary props MayaCmds.select(polyShapeName) MayaCmds.addAttr(longName='SubDivisionMesh', attributeType='bool', defaultValue=False) MayaCmds.addAttr(longName='noNormals', attributeType='bool', defaultValue=False) MayaCmds.addAttr(longName='flipNormals', attributeType='bool', defaultValue=False) # tweek some normals MayaCmds.select(polyName+'.vtxFace[2][1]', replace=True) MayaCmds.polyNormalPerVertex(xyz=(0.707107, 0.707107, 0)) MayaCmds.select(polyName+'.vtxFace[7][4]', replace=True) MayaCmds.polyNormalPerVertex(xyz=(-0.707107, 0.707107, 0)) # write to file self.__files.append(util.expandFileName('staticPolyNormalsTest.abc')) MayaCmds.AbcExport(j='-root %s -f %s' % (polyName, self.__files[-1])) # read back from file MayaCmds.AbcImport(self.__files[-1], mode='import') self.failIf(MayaCmds.listAttr('polyCube1|polyCubeShape').count('noNormals') != 0) # make sure the normals are the same shapeObj = getObjFromName('polyCube1|polyCubeShape') fnMesh = OpenMaya.MFnMesh(shapeObj) numFaces = fnMesh.numPolygons() for faceIndex in range(0, numFaces): vertexList = OpenMaya.MIntArray() fnMesh.getPolygonVertices(faceIndex, vertexList) numVertices = vertexList.length() for v in range(0, numVertices): vertexIndex = vertexList[v] normal = OpenMaya.MVector() fnMesh.getFaceVertexNormal(faceIndex, vertexIndex, normal) vtxFaceAttrName = '.vtxFace[%d][%d]' % (vertexIndex, faceIndex) MayaCmds.select(polyName+vtxFaceAttrName, replace=True) oNormal = MayaCmds.polyNormalPerVertex( query=True, xyz=True) self.failUnlessAlmostEqual(normal[0], oNormal[0], 4) self.failUnlessAlmostEqual(normal[1], oNormal[1], 4) self.failUnlessAlmostEqual(normal[2], oNormal[2], 4)
def smartNormals(reverse=0): '''Changes the vertex normals on a edge by edge basis to that of the larger faces vertex normals''' #We start a new undo chunk to capture all the work cmds.undoInfo( ock=1 ) try: sel = selection() edgeLengthList = getEdgeLengths(sel.selection.keys()) for key in sorted(edgeLengthList, reverse=1): key = key[-1] #Find the dag node name to be used in the polyNormalPerVertex command dagName = key.split('.')[0] cmds.select(dagName) vertices = cmds.ls(cmds.polyListComponentConversion(key,tv=1),fl=1) #Get the edges faces and check to make sure it finds two otherwise skip it because its a boarder edge faces = cmds.ls(cmds.polyListComponentConversion(key,tf=1),fl=1) if len(faces) == 2 : #Get the area of the two faces to compare their size face1Num = int(faces[0].split('[')[-1].split(']')[0]) area1 = getFaceArea(face1Num) face2Num = int(faces[1].split('[')[-1].split(']')[0]) area2 = getFaceArea(face2Num) if area1 > area2 : if reverse: largerFace , smallerFace = face2Num , face1Num else: largerFace , smallerFace = face1Num , face2Num else: if reverse: largerFace , smallerFace = face1Num , face2Num else: largerFace , smallerFace = face2Num , face1Num print "larger face - " + str(largerFace) + " || smaller face - " + str(smallerFace) #For the two verts attached to the edge set the smaller faces vertex normals to the cooresponding larger faces vertex normals #This command is run on the vertex per face so that we can set each one independantly #EXAMPLE: We run it on pCube1.vtxFace [0] [1] which only sets the vertex 0 attached to face 1 #instead of all the faces vertex 0 is attached to if we used pCube1.vtx[0] as the compoenent for vert in vertices : vertNum = int(vert.split('[')[-1].split(']')[0]) #Get the larger faces cooresponding vertex normal normal = cmds.polyNormalPerVertex((dagName + '.vtxFace[' + str(vertNum) + '][' + str(largerFace) + ']'),q=1,xyz=1) #Set the smaller faces cooresponding vertex normal cmds.polyNormalPerVertex((dagName + '.vtxFace[' + str(vertNum) + '][' + str(smallerFace) + ']'),xyz=normal) print "cmds.polyNormalPerVertex((" + dagName + '.vtxFace[' + str(vertNum) + '][' + str(smallerFace) + ']),xyz=' + str(normal) + ')' sel.restoreSelection() except Exception, e: traceback.print_exc()
def GetVertexNormal(vtx): cmds.select(vtx) count = len(cmds.polyNormalPerVertex(q=True, x=True)) x = cmds.polyNormalPerVertex(q=True, x=True) y = cmds.polyNormalPerVertex(q=True, y=True) z = cmds.polyNormalPerVertex(q=True, z=True) avg = [0, 0, 0] dif = 1.0 / count for cnt in range(count): avg[0] += x[cnt] avg[1] += y[cnt] avg[2] += z[cnt] for cnt in range(3): avg[cnt] *= dif return avg
def averageVertexNormal(verts): for v in verts: faces = cmds.polyInfo(v, vertexToFace=True)[0].strip() faces = re.findall(r'\d+', faces)[1:] vn = [0, 0, 0] for f in faces: fn = cmds.polyInfo('%s.f[%s]' % (v.split('.', 1)[0], f), faceNormals=True)[0].strip() fn = fn.split(' ')[-3:] fn = [float(n) for n in fn] vn = map(lambda x, y: x + y, vn, fn) vn = om.MVector(vn[0], vn[1], vn[2]) vn.normalize() vn = (vn.x, vn.y, vn.z) cmds.polyNormalPerVertex(v, xyz=vn)
def unlockVertexNormals(meshList=[]): """ Unlocked vertex normals @param meshList: List of meshes to unlocked normals on. If empty, check all mesh objects in the scene. @type meshList: list """ # Check meshList if not meshList: meshList = getMeshList(meshList) if not meshList: return [] # Unlock Normals for mesh in meshList: cmds.polyNormalPerVertex(mesh, ufn=True) # Return Result return meshList
def unlockVertexNormals(meshList=[]): ''' Unlocked vertex normals @param meshList: List of meshes to unlocked normals on. If empty, check all mesh objects in the scene. @type meshList: list ''' # Check meshList if not meshList: meshList = getMeshList(meshList) if not meshList: return [] # Unlock Normals for mesh in meshList: mc.polyNormalPerVertex(mesh,ufn=True) # Return Result return meshList
def facetoVertNRM(): # FIXME fix usage for faces bordering hard edges. ''' sets the vertex normals of the verts contained in a face to that of the face. ''' fs = cmds.filterExpand(sm=34) cmds.select(cl=True) for f in fs: cmds.select(f, r=True) normals = cmds.polyInfo(faceNormals=True) buf = str(normals).split() plane = range(3) plane[0] = float(buf[2]) plane[1] = float(buf[3]) plane[2] = float(buf[4].rstrip('\\n\']')) vtx = cmds.polyListComponentConversion(f, ff=True, tv=True) cmds.polyNormalPerVertex(vtx, xyz=[plane[0], plane[1], plane[2]])
def getMeshVertexData( mesh ): returnData = [] exportObject = 'bwExportObject' cmds.duplicate( mesh, n=exportObject ) cmds.polyTriangulate(exportObject) numOfFaces = cmds.polyEvaluate(exportObject, f=True ) for i in xrange(0, numOfFaces): faceSelect = exportObject + '.f[' + str(i) + ']' fVertices = [] fVertices = cmds.polyListComponentConversion(faceSelect, ff = True, tvf = True) fVertices = cmds.filterExpand(fVertices, sm = 70, ex = True) print fVertices for vertex in fVertices: faceDict = {} vName = cmds.polyListComponentConversion(vertex, fvf = True, tv = True) xyz = [] xyz = cmds.xform(vName, q = True, os = True, t = True) faceDict['x'] = round(xyz[0], 2) faceDict['y'] = round(xyz[1], 2) faceDict['z'] = round(xyz[2], 2) normal = [] normal = cmds.polyNormalPerVertex(vertex, q = True, xyz = True) faceDict['xN'] = round(normal[0], 2) faceDict['yN'] = round(normal[1], 2) faceDict['zN'] = round(normal[2], 2) # vuv = [] # vuv = cmds.polyListComponentConversion(vertex, fvf = True, tuv = True) # uvCoords = [] # uvCoords = cmds.polyEditUV(vuv[0], q = True, u = True, v = True) # faceDict['u'] = round(uvCoords[0], 2) # faceDict['v'] = round(uvCoords[0], 2) returnData.append(faceDict) cmds.delete(exportObject) return json.dumps(returnData)
def averageNormals(): try: cmds.polyNormalPerVertex(ufn=True) cmds.polyAverageNormal( prenormalize=False, allowZeroNormal=False, postnormalize=True, distance=0.1, replaceNormalXYZ=(1,0,0)) except: cmds.polyAverageNormal( prenormalize=False, allowZeroNormal=False, postnormalize=True, distance=0.1, replaceNormalXYZ=(1,0,0))
def checkLockedVertexNormals(meshList=[]): """ Check for locked vertex normals @param meshList: List of meshes to check for locked normals. If empty, check all mesh objects in the scene. @type meshList: list """ # Check meshList meshList = getMeshList(meshList) if not meshList: return [] # Check Locked Normals lockedNormalList = [] for mesh in meshList: # Shapes meshShapes = mc.listRelatives(mesh, s=True, ni=True, pa=True) if not meshShapes: continue for meshShape in meshShapes: # Check Normals if True in mc.polyNormalPerVertex(meshShape + ".vtx[*]", q=True, fn=True): lockedNormalList.append(mesh) continue # Return Result return lockedNormalList
def checkLockedVertexNormals(meshList=[]): """ Check for locked vertex normals @param meshList: List of meshes to check for locked normals. If empty, check all mesh objects in the scene. @type meshList: list """ # Check meshList meshList = getMeshList(meshList) if not meshList: return [] # Check Locked Normals lockedNormalList = [] for mesh in meshList: # Shapes meshShapes = cmds.listRelatives(mesh, s=True, ni=True, pa=True) if not meshShapes: continue for meshShape in meshShapes: # Check Normals if True in cmds.polyNormalPerVertex(meshShape + '.vtx[*]', q=True, fn=True): lockedNormalList.append(mesh) continue # Return Result return lockedNormalList
def setOrigNormalSoft( target ): ioMeshs = sgModelDag.getIntermediateObjects( target ) for ioMesh in ioMeshs: mesh = cmds.createNode( 'mesh' ) meshObj = sgModelDag.getTransform( mesh ) cmds.connectAttr( ioMesh+'.outMesh', mesh+'.inMesh' ) cmds.refresh() cmds.disconnectAttr( ioMesh+'.outMesh', mesh+'.inMesh' ) cmds.polyNormalPerVertex( mesh, ufn=1 ) cmds.polySoftEdge( mesh, a=180, ch=1 ) cmds.connectAttr( mesh+'.outMesh', ioMesh+'.inMesh' ) cmds.refresh() cmds.disconnectAttr( mesh+'.outMesh', ioMesh+'.inMesh' ) cmds.delete( meshObj )
def getFaceNormals( vertex ): # vertex normal name fvtx = cmds.polyListComponentConversion( vertex, fv=True, tvf=True ) allFvtx = cmds.filterExpand( fvtx, expand=True, sm=70 ) # Face index # vtxFaces = Vertex.getFaceVertexIndex(allFvtx) ''' # There could be duplicate tags, so the dictionary will over write data! tempNormals = {} for i, curFvtx in enumerate(allFvtx): normalCoords = cmds.polyNormalPerVertex( curFvtx, q=True, xyz=True ) curFace = vtxFaces[i] tempNormals[curFvtx] = normalCoords return tempNormals ''' # normals = [] normals = {} for i, curFvtx in enumerate(allFvtx): normalCoords = cmds.polyNormalPerVertex( curFvtx, q=True, xyz=True ) # curFace = vtxFaces[i] normals[curFvtx] = normalCoords # normals.append( normalCoords ) return allFvtx, normals
def getFaceNormals(vertex): # vertex normal name fvtx = cmds.polyListComponentConversion(vertex, fv=True, tvf=True) allFvtx = cmds.filterExpand(fvtx, expand=True, sm=70) # Face index # vtxFaces = Vertex.getFaceVertexIndex(allFvtx) ''' # There could be duplicate tags, so the dictionary will over write data! tempNormals = {} for i, curFvtx in enumerate(allFvtx): normalCoords = cmds.polyNormalPerVertex( curFvtx, q=True, xyz=True ) curFace = vtxFaces[i] tempNormals[curFvtx] = normalCoords return tempNormals ''' # normals = [] normals = {} for i, curFvtx in enumerate(allFvtx): normalCoords = cmds.polyNormalPerVertex(curFvtx, q=True, xyz=True) # curFace = vtxFaces[i] normals[curFvtx] = normalCoords # normals.append( normalCoords ) return allFvtx, normals
def setOrigNormalSoft(target): ioMeshs = sgModelDag.getIntermediateObjects(target) for ioMesh in ioMeshs: mesh = cmds.createNode('mesh') meshObj = sgModelDag.getTransform(mesh) cmds.connectAttr(ioMesh + '.outMesh', mesh + '.inMesh') cmds.refresh() cmds.disconnectAttr(ioMesh + '.outMesh', mesh + '.inMesh') cmds.polyNormalPerVertex(mesh, ufn=1) cmds.polySoftEdge(mesh, a=180, ch=1) cmds.connectAttr(mesh + '.outMesh', ioMesh + '.inMesh') cmds.refresh() cmds.disconnectAttr(mesh + '.outMesh', ioMesh + '.inMesh') cmds.delete(meshObj)
def has_locked_normals(mesh): """Return whether a mesh node has locked normals""" from maya import cmds return any( cmds.polyNormalPerVertex("{}.vtxFace[*][*]".format(mesh), query=True, freezeNormal=True))
def has_locked_normals(self, mesh): mesh_vertexface = cmds.polyListComponentConversion(mesh, toVertexFace=True) locked_normals = cmds.polyNormalPerVertex(mesh_vertexface, q=1, freezeNormal=True) if any(locked_normals): return True else: return False
def NormalAction(fs): for f in fs: node = f.split('.')[0] pi = cmds.polyInfo(f, fn=True) vss = cmds.polyInfo(f, fv=True) fn = re.findall(r"[\w.-]+", pi[0]) # convert the string to array with regular expression vssre = re.findall(r"[\w]+", vss[0]) vs = [] for index in range(2, len(vssre)): vs.append("{0}.vtx[{1}]".format(node, vssre[index])) cmds.select(vs, r=True) cmds.polyNormalPerVertex(xyz=(float(fn[2]), float(fn[3]), float(fn[4])))
def setmesh(nodename): cmds.select(nodename) exts = getnames() va, na, pa, uva = exts nva, nna, npa, nuva = [nodename+"."+ext for ext in exts] # Vertices first. vl = cmds.xform(nodename+'.vtx[:]', q=True, os=True, t=True) cmds.addAttr(longName=va, dt="string") cmds.setAttr(nva, str(vl), type="string") # Polygons (called faces in Maya). pcnt = cmds.polyEvaluate(f=True) cmds.addAttr(longName=pa, dt="string") pll = [] for x in range(pcnt): fvl = cmds.polyInfo(nodename+".f[%i]" % x, faceToVertex=True) p = fvl[0].split()[2:] pll += ["[" + ",".join(p) + "]"] pll = "[" + ",".join(pll) + "]" cmds.setAttr(npa, pll, type="string") pl = eval(pll) # Normals and UVs (needs polygons). nll = [] # UVs are only used if user has set a non-default UV-set # name (use right-click menu). cmds.select(nodename) hasUv = (cmds.polyUVSet(q=True, allUVSets=True) != ['map1']) uvcnt = 0 #print("Set is: "+str(cmds.polyUVSet(q=True, allUVSets=True))) cmds.addAttr(longName=na, dt="string") if hasUv: cmds.addAttr(longName=uva, dt="string") uvll = [] for polyidx in range(pcnt): poly = pl[polyidx] for vtxidx in poly: sel = nodename+".vtxFace["+str(vtxidx)+"]["+str(polyidx)+"]" cmds.select(sel) n = cmds.polyNormalPerVertex(q=True, xyz=True); nll += n if hasUv: uv_names = cmds.polyListComponentConversion(fromVertexFace=True, toUV=True) if uv_names: uv_name = uv_names[0] cmds.select(uv_name) uv = cmds.polyEditUV(q=True) uvll += uv uvcnt += 1 #print "Normals: "+str(nll) cmds.setAttr(nna, str(nll), type='string') if hasUv: #print "UVs: "+str(uvll) cmds.setAttr(nuva, str(uvll), type='string') return (1, len(vl)/3+len(pl)+len(nll)/3+uvcnt)
def createPatchMesh(vertices, normals): width = len(vertices) height = len(vertices[0]) cmds.polyPlane(n="tp", sx=width-1, sy=height-1, ax=[0, 0, 1]) for j in range(height): for i in range(width): cmds.select("tp.vtx[%s]" % (j*width+i), r=True) cmds.move(vertices[i][j][0], vertices[i][j][1], vertices[i][j][2], a=True) cmds.polyNormalPerVertex(xyz=normals[i][j].tolist()) normalZ = cmds.polyInfo("tp.f[0]", fn=True)[0].split()[-1] if normalZ[0]=="-": cmds.polyNormal("tp", normalMode=0, userNormalMode=0, ch=1); cmds.rename("tp", "patch1") cmds.select(cl=True)
def build(self): """ Build the osm file """ print 'Building' # first get a group to put everything in bld_group = '_buildings' if not cmds.ls(bld_group): cmds.group(empty=True, n=bld_group) # create a something to store the number of the building we are on num_buildings = 0 # go through our ways and find the buildings for way in self.ways: if 'building' in way.tags: positions = [] for node_id in way.nodes: node = self.nodes[node_id] pos_xy = self.get_relative_coordinates( [float(node.lat), float(node.lon)]) positions.append((pos_xy[0], pos_xy[1], 0)) building = cmds.polyCreateFacet(p=positions) centre_pos = self.get_centre_pos(positions) cmds.xform(building[0], ws=True, piv=centre_pos) # make sure all the vertices have the correct normals for i in range(cmds.polyEvaluate(building[0], vertex=True)): cmds.select('{}.vtx[{}]'.format(building[0], i)) cmds.polyNormalPerVertex(xyz=(0, 0, 1)) new_building = cmds.rename( building[0], 'building_{0:03d}'.format(num_buildings + 1)) cmds.parent(new_building, bld_group) num_buildings += 1 print 'Build {} buildings!'.format(num_buildings)
def extrude_building(building=None, height=None): """ Given an object will extrude it upwards """ building_face = '{}.f[0]'.format(building) if not height: building_scale = math.ceil( cmds.polyEvaluate(building_face, worldArea=True) / 1000000) if building_scale > 12: building_scale = 12 num_stories = math.floor(random.uniform(1, 3)) * building_scale height = 450 * num_stories cmds.polyExtrudeFacet(building_face, kft=True, ltz=height, sma=0) cmds.polyNormalPerVertex(building, ufn=True)
def fixNormals(*arg): ''' Fix normal for every selected objects''' if commonTools.testSelection() == None: cmds.warning('Nothing is selected') else: sel = commonTools.testSelection() selAD = cmds.listRelatives(sel, ad=True) selShapes = cmds.listRelatives(sel, shapes=True, fullPath=True) # List selected shapes for i in selAD: # Fix normal angles cmds.polyNormalPerVertex(i, ufn=True) # Unlock normals cmds.polySetToFaceNormal(i) # Set to face cmds.polySoftEdge(i, a=60) # Set normal angle to 60 for i in selShapes: # Disable opposite normals cmds.setAttr('%s.doubleSided' % i, 0) cmds.setAttr('%s.opposite' % i, 0) cmds.setAttr('%s.doubleSided' % i, 1) cmds.select(clear=True) cmds.select(sel, r=True) cmds.inViewMessage(amg='Done ! Remember to delete history.', pos='midCenter', fade=True)
def run(): #get selected edgeloop edgeLoop = cmds.ls(selection=True) #get verticles in the edge loop vertLoop = cmds.polyListComponentConversion(edgeLoop, fromEdge=True, toVertex=True) #sort individual verticles into a list vertLoop = cmds.ls(vertLoop, flatten=True) #open undo chunk so entire operation is a single action cmds.undoInfo(openChunk=True) #soften the mesh normals mesh = cmds.listRelatives(parent=1) cmds.polySoftEdge(mesh, angle=180) #run on each vertex on the edgeloop for vert in vertLoop: #unlock the normal of the vertex cmds.polyNormalPerVertex(vert, unFreezeNormal=True) #get the normals of the vertex on the loop vertNormals = list(cmds.polyNormalPerVertex(vert, query=True, xyz=True)) #get only the first three vectors vertNormals = vertNormals[:3] # select the neighboring verticles using the declared function below vertNeighbors(vert, vertLoop) #set their normal angle to match the vertex on the loop cmds.polyNormalPerVertex(xyz=vertNormals) #reselect the edge loops cmds.select(edgeLoop) #close undo chunk, operation is done cmds.undoInfo(closeChunk=True)
def LsUVMap(self): Locator_nodes = mc.ls(sl=True, o=True) if len(Locator_nodes) != 1: mc.confirmDialog(m=u"请选择一个物体!") return mc.select(Locator_nodes[0], r=True) #当前值没有冻结的冻结 mc.polyNormalPerVertex(ufn=True) #选择所有的UV点 mc.select((Locator_nodes[0] + '.map[*]'), r=True) #显示所有修改的部件转变成线 uvBorder = mc.polyListComponentConversion(te=True, internal=True) #查找uvBorder中的线 uvBorder = mc.ls(uvBorder, fl=True) for curEdge in uvBorder: edgeUVs = mc.polyListComponentConversion(curEdge, tuv=True) edgeUVs = mc.ls(edgeUVs, fl=True) if len(edgeUVs) > 2: self.finalBorder.append(curEdge) mc.select(self.finalBorder, r=True) #selectUVEdges().LsUVMap()
def getVertexNormals(vertex): """Returns a list of MVector objects for each normal associated with the specified vertex (one per attached face) """ mc.select(vertex, replace=True) n = mc.polyNormalPerVertex(query=True, xyz=True) normalLs = [] for i in range(0, len(n), 3): # Pack returned values into a list of MVector objects normal = MVector(n[i], n[i + 1], n[i + 2]) normalLs.append(normal) return normalLs
def getFaceNormals( vertex ): # vertex normal name fvtx = cmds.polyListComponentConversion( vertex, fv=True, tvf=True ) allFvtx = cmds.filterExpand( fvtx, expand=True, sm=70 ) # Face index vtxFaces = Vertex.getFaceVertexIndex(allFvtx) tempNormals = {} for i, curFvtx in enumerate(allFvtx): normalCoords = cmds.polyNormalPerVertex( curFvtx, q=True, xyz=True ) curFace = vtxFaces[i] tempNormals[curFace] = normalCoords return tempNormals '''
def solidifyObject(object, height=1, divisions=2, history=True): """ Solidifies given object. :param object: Object. :type object: str :param height: Extrusion height. :type height: float :param division: Extrusion divisions. :type division: float :param history: Keep construction history. :type history: bool """ if hasBorderEdges(object): transform = getTransform(object) vertices = cmds.ls(cmds.polyListComponentConversion(object, toVertex=True), fl=True) barycenters = cmds.xform(vertices, q=True, t=True, ws=True) barycenter = getAverageVector([(barycenters[i], barycenters[i + 1], barycenters[i + 2]) for i in range(0, len(barycenters), 3)]) normals = cmds.polyNormalPerVertex(cmds.polyListComponentConversion(object, toVertexFace=True), q=True, xyz=True) normals = [(normals[i], normals[i + 1], normals[i + 2]) for i in range(0, len(normals), 3)] averageNormal = vectorMatrixMultiplication(normalize(getAverageVector(normals)), cmds.xform(transform, query=True, matrix=True, worldSpace=True)) facesCount = cmds.polyEvaluate(object, face=True) faces = object + ".f[0:" + str(facesCount - 1) + "]" extrude = cmds.polyExtrudeFacet(faces, constructionHistory=1, keepFacesTogether=1, divisions=divisions) cmds.setAttr(extrude[0] + ".localTranslateZ", height) borderEdges = cmds.polyListComponentConversion(faces, te=True, bo=True) cmds.polyMapCut(borderEdges) uvs = cmds.polyListComponentConversion(object + ".f[0:" + str(facesCount - 1) + "]", toUV=1) cmds.polyEditUV(uvs, u=0, v=-5) extendedFaces = cmds.ls(faces, fl=True) for i in range(divisions): adjacentEdges = cmds.polyListComponentConversion(extendedFaces, ff=True, te=True) extendedFaces.extend(cmds.ls(cmds.polyListComponentConversion(adjacentEdges, fe=True, tf=True), fl=True)) borderFaces = list(set(extendedFaces).difference(set(cmds.ls(faces, fl=True)))) cmds.select(borderFaces) cmds.polyAutoProjection(borderFaces, t=barycenter, ry=getAngle((0, 0, 1), averageNormal), rz=getAngle((1, 0, 0), averageNormal)) uvs = cmds.polyListComponentConversion(borderFaces, toUV=1) cmds.polyEditUV(uvs, u=0, v=-5) not history and cmds.delete(object, ch=True)
def getNormal(_vtx): vertName = _obj + '.vtx[' + str(_vtx) + ']' normTemp = cmds.polyNormalPerVertex(vertName, query=True, xyz=True) norms = zip(*[iter(normTemp)]*3) #values for averages xAve=0 yAve=0 zAve=0 #get average vertex normal for i in range (len(norms)): xAve += norms[i][0] yAve += norms[i][1] zAve += norms[i][2] leng = len(norms) xAve = xAve/leng yAve = yAve/leng zAve = zAve/leng aveList = [xAve, yAve, zAve] return aveList
def get_vertex_normals(pObject): '''Gathers all the normal directions for all the vertices of a poly object. Parameters: pObject [str] : The name of a polygonal object from the scene. On Exit: Returns a list of all the vertex normals, averaged from each adjacent face normal. ''' lsVtxNormals = [] nVtx = cmds.polyEvaluate(pObject, vertex=True) for i in range(nVtx): xyzNorm = cmds.polyNormalPerVertex('%s.vtx[%d]' % (pObject, i), q=True, xyz=True) vtxNormal = [sum([xyzNorm[i] for i in range(0+x, len(xyzNorm), 3)]) / \ (len(xyzNorm)/3) for x in range(3)] lsVtxNormals.append(vtxNormal) return lsVtxNormals
def process(self, instance): invalid = list() for mesh in cmds.ls(type="mesh", long=True): faces = cmds.polyListComponentConversion(mesh, toVertexFace=True) if faces: locked = cmds.polyNormalPerVertex(faces, query=True, freezeNormal=True) invalid.append(mesh) if any(locked) else None # On locked normals, indicate that validation has failed # with a friendly message for the user. #assert not invalid, ( # "Meshes found with locked normals: %s" % invalid) if len(invalid) > 0: self.log.warning("Meshes found with locked normals: %s" % invalid) else: self.log.info("The normals of \"%s\" are correct." % instance.data['model'])
def getVertexNormal(P): ''' For a given vertex of a polygon mesh, queries the normal for each vertex-face combination and calculates the average vertex normal. P: input vertex ''' cmds.select(P) # query x,y and z-values of the normals of all faces around the vertex n = cmds.polyNormalPerVertex( query=True, xyz=True ) num = len(n)/3 x = 0 y = 0 z = 0 # calculate average for j in range (0,num): x += n[0+3*j] y += n[1+3*j] z += n[2+3*j] vn = numpy.array([[x/num, y/num, z/num]]) # normalize length = numpy.linalg.norm(vn) vn = vn/length return vn
def export(): get_ui_values() selection = cmds.ls(sl=True) if export_animation: frame_range = range(start_frame, end_frame+1) else: frame_range = cmds.currentTime(query=True), for frame in frame_range: #####FRAME SETTINGS OVERRIDE GENERAL SETTINGS seed = frame cmds.currentTime(frame,edit=True) scene_code = '' scene_code += '{\n'#begin scene_code += ' "resolution": [' + str(resolution_x) + ', ' + str(resolution_y) + '],\n' scene_code += ' "viewport": [0, 0, ' + str(resolution_x) + ', ' + str(resolution_y) + '],\n' scene_code += ' "exposure": ' + str(exposure) + ',\n' scene_code += ' "gamma": ' + str(gamma) + ',\n' scene_code += ' "rays": ' + str(ray_number) + ',\n' if time != 0: scene_code += ' "timelimit": ' + str(time) + ',\n' scene_code += ' "seed": ' + str(int(seed)) + ',\n' #### LIGHTS scene_code += ' "lights": [\n' for obj in cmds.ls(sl=True): shape = cmds.listRelatives(obj, shapes=True) if (cmds.objectType(shape, isType='pointLight') or cmds.objectType(shape, isType='spotLight')) and cmds.getAttr(obj + '.visibility'): wav = HSV2wavelength([cmds.getAttr(shape[0]+'.colorR'), cmds.getAttr(shape[0]+'.colorG'), cmds.getAttr(shape[0]+'.colorB')]) use_spectral = cmds.getAttr(shape[0]+'.hqzSpectralLight') spectral_start = cmds.getAttr(shape[0]+'.hqzSpectralStart') spectral_end = cmds.getAttr(shape[0]+'.hqzSpectralEnd') x, y = get_loc(obj) y = resolution_y-y rot = get_rot(obj) scene_code += ' [ ' scene_code += str(cmds.getAttr(shape[0]+'.intensity')) + ', ' #LIGHT POWER scene_code += str(x) + ', ' #XPOS scene_code += str(y) #YPOS scene_code += ', [0, 360], [' #POLAR ANGLE scene_code += str(cmds.getAttr(shape[0]+'.hqzLightStart')) + ', ' #POLAR DISTANCE MIN scene_code += str(cmds.getAttr(shape[0]+'.hqzLightEnd')) + '], [' #POLAR DISTANCE MIN #scene_code += '0' + ', ' #POLAR DISTANCE MIN #scene_code += '0' + '], [' #POLAR DISTANCE MAX if cmds.objectType(shape, isType='spotLight'): scene_code += str(-rot-cmds.getAttr(shape[0]+'.coneAngle')*0.5) + ', ' #ANGLE scene_code += str(-rot+cmds.getAttr(shape[0]+'.coneAngle')*0.5) + '], ' else: scene_code += '0, 360], ' if use_spectral: scene_code += '[' + str(spectral_start) + ', ' + str(spectral_end) + '] ],\n' #WAVELENGTH else: scene_code += str(int(wav)) +' ],\n' #WAVELENGTH scene_code = scene_code[:-2]#remove last comma scene_code += '\n ],\n' scene_code += ' "objects": [\n' #### GET MAYA EDGE LIST edge_list = [] for obj in cmds.ls(sl=True): shape = cmds.listRelatives(obj, shapes=True) if cmds.objectType(shape, isType='mesh') and (cmds.getAttr(obj + '.v')): cmds.select(obj) edge_info = cmds.polyInfo(edgeToVertex=True)#get vertices connected to edge #print(edge_info) edges=[] for edge in edge_info: #print(edge) edge = edge.split(':')[1] edge = [int(edge[:7]),int(edge[8:15])] #print(edge.split(' '))#get vertices connected to edge edges.append(edge) #print(edges) for edge in edges: edgev = [] # vertices = list(edge.vertices) #material = obj.split('_')[1] material = str(cmds.getAttr(shape[0]+'.hqzMaterial')) edgev.append(material) edgev.append(cmds.xform(obj+'.vtx[%i]' % edge[0], translation=True, absolute=True, worldSpace=True, query=True)) edgev.append(cmds.xform(obj+'.vtx[%i]' % edge[1], translation=True, absolute=True, worldSpace=True, query=True)) if export_normals: #print(vertices[0]) for v_ix in range(2): cmds.select(obj+'.vtx[%i]' % edge[v_ix]) vectors = cmds.polyNormalPerVertex(query=True, xyz=True) edgev.append(cmds.xform(obj, rotation=True, query=True)[2] + vector2rotation([vectors[0],vectors[1]])) #edgev.append((obj.rotation_euler[2] * 180/pi) + vector2rotation(obj.data.vertices[vertices[0]].normal)) #edgev.append((obj.rotation_euler[2] * 180/pi) + vector2rotation(obj.data.vertices[vertices[1]].normal)) #print(edgev) if check_Z: #print(fabs(cmds.xform(obj+'.vtx[%i]' % edge[0], translation=True, absolute=True, worldSpace=True, query = True)[2])) if fabs(cmds.xform(obj+'.vtx[%i]' % edge[0], translation=True, absolute=True, worldSpace=True, query=True)[2]) < 0.0001 \ and fabs( cmds.xform(obj+'.vtx[%i]' % edge[1], translation=True, absolute=True, worldSpace=True, query=True)[2]) < 0.0001: edge_list.append(edgev) else: edge_list.append(edgev) #print(edgev) #print(edge_list) ####OBJECTS for edge in edge_list: #print(edge) scene_code += ' [ ' scene_code += str(edge[0]) + ', ' #MATERIAL scene_code += str(edge[1][0]*resolution_x) + ', ' #VERT1 XPOS scene_code += str(resolution_y - (edge[1][1]*resolution_x)) + ', ' #VERT1 YPOS if export_normals: scene_code += str(edge[3]) + ', ' #VERT1 NORMAL scene_code += str(edge[2][0]*resolution_x - (edge[1][0]*resolution_x)) + ', ' #VERT2 DELTA XPOS scene_code += str(-1 * (edge[2][1]*resolution_x - (edge[1][1]*resolution_x))) + '],' #VERT2 DELTA YPOS if export_normals: scene_code = scene_code[:-2]#remove last comma and bracket normal = (edge[4]) - (edge[3]) if normal < -180: normal += 360 if normal > 180: normal -= 360 scene_code += ',' + str(normal) + '],' #VERT2 NORMAL scene_code += '\n' scene_code = scene_code[:-2]#remove last comma scene_code += '\n ],\n' scene_code += ' "materials": [\n' cmds.select(selection, replace=True) ###mats for mat in materials: scene_code += ' [ [ ' + str(mat[0]) + ', "d" ],[ ' + str(mat[1]) + ', "t" ],[ ' + str(mat[2]) + ', "r" ] ],\n' scene_code = scene_code[:-2]#remove last comma scene_code += '\n ]\n' scene_code += '}' #print(scene_code) if debug: scene_code = scene_code.replace('\n', '') print(scene_code) #folder = folder save_path = folder + '\\' + file_name + '_' + str(int(frame)).zfill(4) + '.json' save_path.replace('/', '\\') print(save_path) d = os.path.dirname((folder+'\\').replace('/', '\\')) if not os.path.exists(d): os.makedirs(d) file = open(save_path, 'w') file.write(scene_code) file.close() ###DIRTY LOOP FOR BASH SCRIPT. I SHOULD LEARN THINGS if export_batch: shell_path = (folder+'\\').replace('/', '\\')+'batch.bat' shell_script = '' for frame in frame_range: shell_script += engine_path.replace('/', '\\') + ' ' + (folder+'\\').replace('/', '\\') + file_name + '_' + str(int(frame)).zfill(4) +".json " + folder + '\\' + file_name + '_' + str(int(frame)).zfill(4) +".png\n" file = open(shell_path, 'w') file.write(shell_script) file.close()
def repair(cls, instance): """Unlocks all normals on the meshes in this instance.""" invalid = cls.get_invalid(instance) for mesh in invalid: cmds.polyNormalPerVertex(mesh, unFreezeNormal=True)
def has_locked_normals(mesh): """Return whether a mesh node has locked normals""" return any(cmds.polyNormalPerVertex(mesh + ".vtxFace[*][*]", query=True, freezeNormal=True))
def get_vnormal(shape, vert_itx, face_idx): vec = om.MVector() attr = '%s.vtxFace[%d][%d]' % (shape, vert_itx, face_idx) vec = mc.polyNormalPerVertex(attr, q=True, xyz=True) return vec
def normUn(*args): cmds.polyNormalPerVertex(ufn=True)