Python cmds.polyUnite函数代码示例

  def generate(cls, *args):
    components = []
    boolean = []
    width = cmds.intSliderGrp(cls.get_prefix() + Labels["width_label"], query=True, value=True)
    rgb = cmds.colorSliderGrp(cls.get_prefix() + Labels["color_label"], query=True, rgbValue=True)

    block_width = width * Constants["block_width_unit"]
    block_height = Constants["block_height_unit"]
    block_depth = Constants["block_depth_unit"]

    for x in range(0, width):
      stub = cmds.polyCylinder(name=get_unique_name(cls.get_prefix(), "Stub"), radius=Constants["stub_radius"], height = Constants["stub_height"])
      components.append(stub[0])
      cmds.move(Constants["block_width_unit"] * x + half(Constants["block_width_unit"]), half(Constants["block_height_unit"]) + half(Constants["stub_height"]), half(Constants["block_depth_unit"]), stub[0])
      
    for x in range(0, width-1):
      hole = cmds.polyCylinder(name=get_unique_name(cls.get_prefix(), "Hole"), radius=Constants["perforation_radius"], height=Constants["block_depth_unit"] + 0.2)
      boolean.append(hole[0])
      cmds.rotate('90deg', 0, 0, hole[0])
      cmds.move(Constants["block_width_unit"] * x + Constants["block_width_unit"], 0, half(Constants["block_depth_unit"]), hole[0])

    cube = cmds.polyCube(sx=5,sy=2,sz=2,name=get_unique_name(cls.get_prefix(), "block"), width=block_width, height=block_height, depth=block_depth)
    components.append(cube[0])
    cmds.move(half(width * Constants["block_width_unit"]), 0, half(Constants["block_depth_unit"]), cube)
    solid = cmds.polyUnite(components, name=get_unique_name(cls.get_prefix(), ""))
    boolean_group = cmds.polyUnite(boolean, name=get_unique_name(cls.get_prefix(),"boolean"))
    final = cmds.polyBoolOp( solid[0], boolean_group[0], op=2, n=get_unique_name(cls.get_prefix(), "") )

    shader = cmds.shadingNode('blinn', asShader=True, name=get_unique_name(cls.get_prefix(),"mat"))
    cmds.setAttr(shader + ".color", rgb[0],rgb[1],rgb[2], type='double3')
    cmds.select(final[0], r=True)
    cmds.hyperShade(assign=shader)

  def generate_kink_peice(cls, block_width):
    components = []
    boolean = []
    for x in range(0, block_width + 1):
      hole = cmds.polyCylinder(name=get_unique_name(cls.get_prefix(), "Hole"), radius=Constants["perforation_radius"], height=Constants["block_depth_unit"] + 0.2)
      boolean.append(hole[0])
      cmds.rotate('90deg', 0, 0, hole[0])
      cmds.move(Constants["block_width_unit"] * x , 0, half(Constants["block_depth_unit"]), hole[0])

    cube = cmds.polyCube(sx=5,sy=2,sz=2,name=get_unique_name(cls.get_prefix(), "block"), width=block_width, height=Constants["block_height_unit"], depth=Constants["block_depth_unit"])
    components.append(cube[0])
    cmds.delete(cube[0] + ".f[40:47]")
    cmds.move(half(block_width * Constants["block_width_unit"]), 0, half(Constants["block_depth_unit"]), cube)

    #caps
    cap_one = cmds.polyCylinder(sc=1, sy=2, radius=half(Constants["block_height_unit"]), height=Constants["block_depth_unit"],name=get_unique_name(cls.get_prefix(), "cap"))
    cmds.rotate('90deg',0,0,cap_one[0])
    cmds.move(0,0,half(Constants["block_depth_unit"]),cap_one[0])
    cmds.delete(cap_one[0] + ".f[0:3]", cap_one[0] + ".f[14:23]", cap_one[0] + ".f[34:43]", cap_one[0] + ".f[54:63]", cap_one[0] + ".f[74:79]")
    components.append(cap_one[0])

    #caps
    cap_two = cmds.polyCylinder(sc=1, sy=2, radius=half(Constants["block_height_unit"]), height=Constants["block_depth_unit"])
    cmds.rotate('90deg','180deg',0,cap_two[0])
    cmds.delete(cap_two[0] + ".f[0:3]", cap_two[0] + ".f[14:23]", cap_two[0] + ".f[34:43]", cap_two[0] + ".f[54:63]", cap_two[0] + ".f[74:79]")
    cmds.move(block_width,0,half(Constants["block_depth_unit"]),cap_two[0])
    components.append(cap_two[0])

    solid = cmds.polyUnite(components, name=get_unique_name(cls.get_prefix(), ""))
    boolean_group = cmds.polyUnite(boolean, name=get_unique_name(cls.get_prefix(),"boolean"))
    cmds.polyMergeVertex( solid[0], d=0.15 )
    cmds.delete(solid[0],ch=1)
    return cmds.polyBoolOp( solid[0], boolean_group[0], op=2, n=get_unique_name(cls.get_prefix(), "") )

def dup(*args):
	neg = cmds.checkBox("negChck", q=True, v=True)
	mrge = cmds.checkBox("mrgChck", q=True, v=True)
	dupAx = cmds.radioButtonGrp("axChck", q=True, sl=True)
	selected = cmds.ls(sl=True)
	print(mrge)
	
	if(dupAx==1):
		scaD = ".scaleX"
	if(dupAx==2):
		scaD = ".scaleY"
	if(dupAx==3):
		scaD = ".scaleZ"
		
	if(neg==1):
		scaVal = -1
	else:
		scaVal = 1
	
	newDup = cmds.duplicate(rr=True)
	cmds.setAttr(newDup[0] + scaD, scaVal)
		
	if (mrge==1):
		cmds.polyUnite(selected, newDup[0])
		cmds.polyMergeVertex(d=1)	
	else:	
		None

def makeStreetTree(shaders):
    '''
    Creates a tree on a circular platform and with a circular fence around it.
    
    shaders: A list of shaders for the tree crowns.
    On exit: A tree has been created using makeTree(...), a circular platform
             has been created underneath it and a fence around it. Appropriate 
             shaders have been assigned. Everything is united into one polygonal
             object and returned as a tuple with the object name and the node 
             name.
    '''
    tree = makeTree(shaders)
    platform = cmds.polyCylinder(name = "platform",h = 0.1, r = 0.8)
    cmds.move(0.25, y = True)
    cmds.sets(platform[0], edit=True, forceElement="fountainMaterialGroup")
    pole = cmds.polyCube(name = "pole", h = 0.6, w = 0.04, d = 0.04)
    cmds.xform(pole, t = (0.7,0.45,0))
    angle = 360/10.0
    for i in range(1,10):
        pole1 = cmds.polyCube(name = "pole", h = 0.6, w = 0.04, d = 0.04)
        cmds.rotate(angle * i, y = True)
        cmds.move(0.7,0.45,0, os = True)
        pole = cmds.polyUnite(pole, pole1)
    bar = cmds.polyPipe(name = "bar", h = 0.1, r = 0.65, t = 0.04)
    cmds.move(0.65, y = True)
    bar1 = cmds.duplicate(bar[0])
    cmds.move(-0.2, y = True, r = True)
    fence = cmds.polyUnite(pole, bar, bar1)
    cmds.sets(fence[0], edit=True, forceElement="blackMetalGroup")
    streetTree = cmds.polyUnite(tree,platform, fence)
    cmds.delete(streetTree, ch = True)
    return streetTree

	def chipFacesTool(self):
		# cuts faces off of the poly and then seperates the faces to it's own polygon object, also ungroups them
		selectedFaces = self.getSelection()
		selectionParent = cmds.listRelatives(selectedFaces[0], p=True)
		cmds.polyChipOff( selectedFaces, dup=True)
		seperated = cmds.polySeparate(selectionParent[0])
		allSeperated = [i for i in seperated if 'Separate' not in i]
		if len(allSeperated) > 2:
			cmds.polyUnite(allSeperated[1:])
			new = self.getSelection()
		else:
			new = allSeperated[1]
		old = []; old.append(allSeperated[0])
		oldParent = cmds.listRelatives(old[0], p=True)
		oldParentChildren = cmds.listRelatives(oldParent[0], c=True)
		oldNodesToDelete = set(old) ^ set(oldParentChildren)
		print oldNodesToDelete, ' this is old nodes to delete'
		cmds.ungroup( oldParent )
		cmds.delete(new, ch=1)
		cmds.delete(old, ch=1)
		cmds.rename(old, oldParent )
		cmds.select(new)
		self.assignRandomMaterial() # assigns random lambert to newly created poly
		cmds.delete(selectedFaces)
		cmds.select(old)
		cmds.xform(centerPivots = True)
		cmds.select(new) # reselect it after material assign
		cmds.xform(centerPivots = True) # Center pivot of new article.
		JR_rename_tool.UI('exit') # to rename the freshly branched poly

 def combine( self ):
     cmds.duplicate( self.original_selected_objects, name="special_copy" )
     self.selected_objects = cmds.ls( selection=True )
     self.duplicate_name = self.original_selected_objects[0] + "_Combined_Copy"
     cmds.polyUnite( self.selected_objects, name=self.duplicate_name )
     cmds.delete( constructionHistory=True )
     if( len(cmds.ls( "special_copy" )) == 1 ):
         cmds.delete( self.selected_objects )

def getRevolveValues():
    # select all geometry, Unite and duplicate it
    cmds.select(cmds.listRelatives(cmds.ls(geometry=True), p=True, path=True), r=True)
    cmds.polyUnite(n='set')
    cmds.duplicate('set')    
    lor = cmds.intSliderGrp(LevelsOfRevolution,q=True,v=True)
    rot = cmds.floatSliderGrp(rotationDistance,q=True,v=True)
    revolve(lor,rot)

 def fnCreateFactor(lstChunkedUp, intFactor):
     lstTranches = []
     for intChunkNum in range(0, len(lstChunkedUp)):
         strPolyName =  cmds.polyCube(sx=1, sy=1,sz=1, cuv=0, w=fltSize, h=fltSize, d=fltSize, name='STVPolyBase')[0]                #create the shape   
         strTrancheName = fnUniteMesh(lstChunkedUp[intChunkNum], intChunkNum, strPolyName)    
         lstTranches.append(strTrancheName)    
     strFactor = 'STVPoly_Factor_' + str(intFactor)
     cmds.polyUnite(lstTranches, n=strFactor)
     cmds.delete(strFactor, ch=True)
     return(strFactor)

 def fnUniteMesh(lstChunk, intChunkNumber, strPName):        
     lstSelectedObjects = cmds.ls('STVPoly*')
     lstTranche = []
     for lstObj in lstChunk:
         fltAdjTemp = fnTempScalar(float(lstObj[2]))
         strInts = fnCreateCylinder(int(lstObj[1]), int(lstObj[0]), fltAdjTemp, str(lstObj[3]), strPName)         #NEED to add function here for temp
         lstTranche.append(strInts)        
     lstSelectedObjects = cmds.ls('STVPoly*')          
     if len(lstTranche) > 1:
         strPolyMeshName = 'STVPolyMesh_Factor' + str(lstObj[3]) + '_Tranche_' + str(intChunkNumber)
         cmds.polyUnite(lstTranche, n=strPolyMeshName)
         cmds.delete(strPolyMeshName, ch=True)
     cmds.delete(lstTranche)
     return(strPolyMeshName)                                         

def os_mergeGroups():
    sel = mc.ls(sl = True)
    for each in sel:
        c = mc.listRelatives(each,c = True, ad = True, type = 'transform')
        geoArr = []
        for child in c:
            if '_geo' in child:
                geoArr.append(child)
        
        print each+' : '+str(len(geoArr)) + ' geos combined.'
        if len(geoArr) == 1:
            mc.parent(geoArr[0], w=True)
        else:
            mc.polyUnite (each, ch = 0, mergeUVSets = 1, centerPivot = True, name = each)

 def __init__(self, name_, height, width, depth, shader):
     '''
     Initializes a BoxHouse object, and creates a polygonal house object based on a
     box primitive.
     
     self: Object that is to be initialized.
     name_: name_: A string with the name the polygonal house object will have.
     height: The height of the house.
     width: The width of the house.
     depth: The depth of the house.
     shader: Shader that will be assigned to the house. 
     On exit: A BoxHouse object has been initialized and a polygonal house has 
              been created out of a box primitive. A foundation for the house has
              also been created and united with the box. The given shader has been 
              assigned to the house. 
     '''
     House.__init__(self, name_, "box", height, width, depth)
     n = cmds.polyCube(n = "house_", w = width, h = height, d = depth, sy = height)
     cmds.xform(n[0], translation = (0, height/2.0, 0))
     f = cmds.polyCube(n = "foundation", w = width + 0.3, h = 0.8, d = depth + 0.3)
     cmds.xform(f[0], translation = (0,0.4,0))
     n = cmds.polyUnite(n[0],f[0], n = name_)
     self.name = n[0]
     cmds.sets(n[0], edit=True, forceElement= shader[1])
     cmds.delete(self.name, ch = True)

def pointFaceMesh(pointList,scale=0.05,combine=True,prefix='pointFace'):
	'''
	'''
	# Get encoded point list
	ptList = []
	for point in pointList:
		ptList.append(glTools.utils.base.getPosition(point))
	
	# Create face for each point
	faceList = []
	vscale = scale * 0.5
	hscale = scale * 0.866
	for pt in ptList:
		face = mc.polyCreateFacet(p=[(pt[0],pt[1]+scale,pt[2]),(pt[0]+hscale,pt[1]-vscale,pt[2]),(pt[0]-hscale,pt[1]-vscale,pt[2])])[0]
		face = mc.rename(face,prefix+'_mesh')
		faceList.append(face)
	
	# Define return list
	mesh = faceList
	
	# Combine faces to single mesh
	if combine:
		mesh = mc.polyUnite(faceList,ch=False)
		mesh = [mc.rename(mesh[0],prefix+'_mesh')]
	
	# Return result
	return mesh

def combine():
    """
    a cleaner combine
    """
    selection = cmds.ls(sl=True, type='mesh', dag=True)
    if not selection or selection < 2:
        cmds.warning('Please select at least 2 meshes!')

    # get full path
    meshFull = cmds.listRelatives(selection[0], p=True, f=True)
    # get parent
    meshParent = cmds.listRelatives(meshFull, p=True, f=True)
    meshInWorld = []
    if meshParent:
        meshParent0 = meshParent[0]
        meshInWorld.append(cmds.parent(meshFull, world=True)[0])
    else:
        meshInWorld = meshFull
    # replace 1st mesh in sel by mesh in world
    selection[0] = meshInWorld[0]
    # get pivots
    pivots = cmds.xform(meshInWorld[0], q=True, ws=True, a=True, rotatePivot=True)
    # combine & rename
    newMesh = cmds.polyUnite(selection, o=True)
    newMeshName = cmds.rename(newMesh[0], meshInWorld[0])
    # set pivot
    cmds.xform(newMeshName, rotatePivot=pivots)
    # reparent
    if meshParent:
        newMeshName = cmds.parent(newMeshName, meshParent, a=True)

    # delete history
    cmds.delete(newMeshName, ch=True, hi='none')

def makeTree(shaders):
    '''
    Creates a tree.
    
    shaders: A list of shaders for the tree crown.
    On exit: A tree has been modeled, and is returned as a tuple 
             containing the object name and the node name. Some of the
             variables are chosen randomly to create different results.
    '''
    height = random.uniform(0.3,1.5)
    trunk = cmds.polyCylinder(name = "trunk", h = height, r = 0.07)
    cmds.sets(trunk[0], edit=True, forceElement="trunkMaterialGroup")
    cmds.xform(trunk, translation = (0,height/2.0 + 0.2,0))
    crown = cmds.polySphere(name = "crown", r = 0.5)
    cmds.xform(crown, translation = (0,height + 0.6,0))
    cmds.softSelect(sse = True, ssd = 0.86)
    cmds.select(crown[0] + ".vtx[381]")
    translation = random.uniform(0.3,1.5)
    cmds.move(translation, y = True, r = True)
    cmds.softSelect(sse = False)
    shader = random.choice(shaders)
    scale_ = random.uniform(0.7,1.8)
    cmds.select(crown)
    cmds.scale(scale_, scale_, scale_, pivot = (0,height,0))
    cmds.sets(crown[0], edit=True, forceElement= shader[1])
    tree = cmds.polyUnite(trunk[0],crown[0])
    cmds.delete(tree[0], ch = True)
    return tree

def movePolysFromObj():
    """
    # 1. Select faces
    # 2. Shift-select targetObj
    # 3. Run
    """
    selFaces = mc.ls(os=1, fl=1)[:-1]
    selFacesIds = [int(faceName.split("[")[1][:-1]) for faceName in selFaces]

    # target object is the last selected item
    targetObj = mc.ls(os=1, fl=1)[-1]
    targetObjParent = mc.listRelatives(targetObj, p=1)[0]

    # delete the parentConstraint if necessary
    targetObjChildren = mc.listRelatives(targetObj, c=1, type="parentConstraint")
    if not targetObjChildren == None:
        mc.delete(targetObjChildren)

    srcObj = selFaces[0].split(".")[0]
    tempObj = mc.duplicate(srcObj, n="tempObj")[0]
    mc.delete(selFaces)

    facesToCopy = [faceName.replace(srcObj, tempObj) for faceName in selFaces]
    mc.select(facesToCopy, r=1)
    meval("InvertSelection;")
    mc.delete()

    combinedGeo = mc.polyUnite(tempObj, targetObj, ch=0, n="combinedGeo")[0]
    mc.rename(combinedGeo, targetObj)
    mc.parent(targetObj, targetObjParent)
    mc.polyMergeVertex(targetObj, d=0.001, ch=0)
    mc.delete(tempObj)
    mc.select(srcObj, r=1)