def make_shape(type, name, divisions): """ Creates shape based on argument passed Args: type: {cube, cone, cylinder, plane, torus, sphere} name: name of the object divisions: number of subdivisions we want to apply in x,y and z axis. Same value will be taken in all axis. Return: None """ if type == 'cube': mc.polyCube(n=name, sx=divisions, sy=divisions, sz=divisions) elif type == 'cone': mc.polyCone(n=name, sx=divisions, sy=divisions, sz=divisions) elif type == 'cylinder': mc.polyCylinder(n=name, sx=divisions, sy=divisions, sz=divisions) elif type == 'plane': mc.polyPlane(n=name, sx=divisions, sy=divisions) elif type == 'torus': mc.polyTorus(n=name, sx=divisions, sy=divisions) elif type == 'sphere': mc.polySphere(n=name, sx=divisions, sy=divisions) else: mc.polySphere()
def create_pointer(m): if (BAXER_POINTER == True): # import Baxter Pointer model and use it try: cmds.loadPlugin("objExport") except: pass name = os.path.dirname(os.path.realpath(__file__)) + "/models/baxter_gripper.obj" mel.eval('file -import -type "OBJ" -ignoreVersion -ra true -mergeNamespacesOnClash false -rpr "gripper" -options "mo=1" -pr "%s";' \ % name) try: mel.eval('rename "gripper_Mesh" "pointer' + str(m) + '";') except: pass else: # Create a pointer mesh that represents the robot claw cmds.polyCone(name="pointer" + str(m), sx=3, r=0.5, h=2) cmds.select("pointer" + str(m)) cmds.rotate("180deg", 0, 0, r=True) cmds.move(0, -1, 0, "pointer" + str(m) + ".scalePivot", "pointer" + str(m) + ".rotatePivot") cmds.move(0, 1, 0, absolute=True) cmds.makeIdentity(apply=True, t=1, r=1, s=1) bbx = cmds.xform("table", q=True, bb=True, ws=True) cur_size = abs(bbx[3] - bbx[0]) cmds.scale(cur_size/TABLE_SIZE, cur_size/TABLE_SIZE, cur_size/TABLE_SIZE, "pointer" + str(m), centerPivot = True) mel.eval('select -r pointer' + str(m) + '; sets -e -forceElement pointer_matSG;') mel.eval("makeCollideNCloth")
def create_pointer(n): cmds.polyCone(name="pointer"+str(n), sx=3, r=0.5, h=2) cmds.select(clear=True) cmds.select("pointer"+str(n)) cmds.rotate("180deg", 0, 0, r=True) cmds.move(0, -1, 0, "pointer" + str(n) + ".scalePivot", "pointer" + str(n) + ".rotatePivot") cmds.move(0, 1, 0, absolute=True) cmds.makeIdentity(apply=True, t=1, r=1, s=1) mel.eval("makeCollideNCloth")
def spawnInCircle(nurbsName, num): radius = cmds.getAttr('%s.radius'%cmds.listConnections(cmds.listRelatives(nurbsName))[0]) position = cmds.xform(nurbsName, q=True, t=True) rotation = cmds.xform(nurbsName, q=True, ro=True) for obj in xrange(num): cmds.polyCone() cmds.xform(t=position) cmds.xform(ro=rotation) cmds.rotate(0, random.uniform(0,360), 0, os=True, r=True) cmds.move( random.uniform(0, radius),0, 0, os=True, r=True)
def RandomCone(): cmds.polyCone( r = random.randrange(1,50),h = random.randrange(1,50), sx=4, sy=4, sz=4) cmds.select() Transforms() cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0) created.append(cmds.ls(selection=True)) cmds.duplicate() cmds.scale(-1,1,1) created.append(cmds.ls(selection=True))
def create_pointer(m): # Create a pointer mesh that represents the robot claw cmds.polyCone(name="pointer" + str(m), sx=3, r=0.5, h=2) mel.eval('select -r pointer' + str(m) + '; sets -e -forceElement pointer_matSG;') cmds.select("pointer" + str(m)) cmds.rotate("180deg", 0, 0, r=True) cmds.move(0, -1, 0, "pointer" + str(m) + ".scalePivot", "pointer" + str(m) + ".rotatePivot") cmds.move(0, 1, 0, absolute=True) cmds.makeIdentity(apply=True, t=1, r=1, s=1) mel.eval("makeCollideNCloth")
def __init__ (self, pos): self.cone = cmds.polyCone (axis = (0,-1,0), subdivisionsX = 16, constructionHistory = False) cmds.xform (self.cone, worldSpace = True, absolute = True, translation = (0,1,0)) cmds.xform (self.cone, pivots =(0,-1,0)) cmds.makeIdentity (apply = True, translate = True) cmds.xform (self.cone, worldSpace = True, absolute = True, translation = pos)
def __init__(self, n): self._object = cmds.polyCone(name = n, height = 0.8, radius = 0.3) self._name = n self._position = V(0.0, 0.0, 0.0) self._velocity = V.random() self._acceleration = V(0.01, 0.0, 0.0) self._maxSpeed = 4.0 self.wanderVector = V(0.0, 1.0, 0.0) self.neighborhoodRadius = 6
def tieOff(): global balloonRadius, balloonQuantity knotVals = mc.pointPosition('balloonTemp.vtx[96]', w=True) knotThickness = balloonRadius * .05 endHeight = balloonRadius * .15 knotRadius = knotVals[0] knotPos = ( knotVals[1] - (.5 * knotThickness)) mc.polyCylinder( n="knotTemp", r=knotRadius, h=knotThickness, sx=12, sy=3, sz=0, rcp=0, cuv=3) mc.delete( 'knotTemp.f[36:37]') mc.setAttr( 'knotTemp.translateY', knotPos ) mc.scale(1.25, 1.75, 1.25, 'knotTemp.vtx[12:35]', r=True ) mc.lattice( n='knot', cp=True, dv =(2, 2, 2), objectCentered=True, ldv=(2,2,2)) mc.move( (.75 * knotThickness), 'knotLattice.pt[1][0][0:1]', r=True, y=True) mc.move( (.25 * knotThickness), 'knotLattice.pt[0][0][0:1]', r=True, y=True) mc.duplicate('knotTemp') mc.rotate(180, 'knotTemp1', z=True) mc.polyCone( n="endTemp", r=knotRadius*2, h=endHeight, sx=12, sy=6, sz=3, rcp=0, cuv=3) mc.delete( 'endTemp.f[60:83]', 'endTemp.f[96:107]') mc.setAttr( 'endTemp.translateY', knotPos - knotThickness/2 ) mc.scale( 1.15, 1, 1.15, 'endTemp.vtx[36:59]') mc.move((.5 * endHeight), 'endTemp.vtx[0:11]', 'endTemp.vtx[72]', y=True, r=True) mc.polyUnite( 'balloonTemp', 'knotTemp', 'knotTemp1', 'endTemp', ch=True ) mc.polySoftEdge( a = 180 ) mc.polyMergeVertex( d=.001) mc.polyEditUV('polySurface1.map[0:126]', pu=0.5, pv=1, su=1, sv=0.575) mc.polyEditUV('polySurface1.map[127:230]', pu=0.5, pv=0.35, su=2, sv=.25) mc.polyEditUV('polySurface1.map[267:318]', u=0, v=-0.1, pu=0.5, pv=0, su=1, sv=.5) mc.polyEditUV('polySurface1.map[231:266]', 'polySurface1.map[319]', u=0, v=-.175, pu=0.5, pv=0.25, su=0.25, sv=0.25) mc.polyMergeUV('polySurface1.map[103:126]', d=0.5, ch=True ) mc.polyEditUV('polySurface1.map[104]', r=False, u=0) mc.polyEditUV('polySurface1.map[103]', r=False, u=1) mc.polySmooth('polySurface1', mth=0, dv=1, c=1, kb=0, ksb=1, khe=0, kt=1, kmb=0, suv=0, peh=0, sl=1, dpe=1, ps=0.1 , ro=1, ch=True) mc.DeleteHistory() mc.delete( 'knotTemp1') mc.rename('polySurface1', 'balloon1') mc.select(cl=True) return
def init(): print "Custom simulation initialised" # reset last frame counter global last_frame_number last_frame_number = 1 global agent0_name agent0_name = "pCone1" if cmds.objExists(agent0_name) is False: cmds.polyCone(sx=4, n = agent0_name) print "Cone Made" cmds.setAttr( agent0_name+".rotateY",45.0) cmds.setAttr( agent0_name+".rotateZ",90.0) cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0) cmds.setAttr( agent0_name+".scaleY" ,0.75) cmds.setAttr( agent0_name+".rotateY" ,90.0) cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0) cmds.delete(ch=True) agent_setup(agent0_name)
def fib_seq(): a, b = 0, 1 while b < limit: a, b = b, a+b cube = cmds.polyCone(h=10,r=10) # make a new brush cube cmds.move(b/2,-b/2,0) #cut the sequence scale cmds.move(cube[0]+".scalePivot",cube[0]+".rotatePivot", absolute=True)# move pivit to origin cmds.select(cmds.listRelatives(cmds.ls(geometry=True), p=True, path=True), r=True) # select all geometry cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0) # freeze transforms cmds.rotate(0,rot,0) # rotate all
def volumeScatter(name, count): a=[] bbox = cmds.exactWorldBoundingBox(name) for i in range(count): x = random.uniform(bbox[0], bbox[3]) y = random.uniform(bbox[1], bbox[4]) z = random.uniform(bbox[2], bbox[5]) newObj = cmds.polyCone()[0] a.append(newObj) cmds.move(x,y,z,newObj) return a
def __init__( self, *args, **kwargs ): # Create the animal name # For object identification & name of attached polyShape self.animalName = kwargs.setdefault( "animalName" ) # Create shared attributes self.initialPosition = kwargs.setdefault( "initialPosition" ) self.initialHeading = kwargs.setdefault( "initialHeading" ) self.initialSpeed = kwargs.setdefault( "initialSpeed" ) self.speed = kwargs.setdefault( "initialSpeed" ) # Create a cone to represent the animal # Created aligned with positive z-axis self.cone = cmds.polyCone( name = self.animalName, axis = [ 0, 0, 1 ], height = 2, radius = 1 ) # Create and set the initial position if cmds.objExists( self.animalName+".initialPositionX" ) is False: cmds.addAttr( self.animalName, longName = "initialPositionX", defaultValue = 0.0, keyable = True ) cmds.setAttr( self.animalName+".initialPositionX", self.initialPosition.x ) if cmds.objExists( self.animalName+".initialPositionY" ) is False: cmds.addAttr( self.animalName, longName = "initialPositionY", defaultValue = 0.0, keyable = True ) cmds.setAttr( self.animalName+".initialPositionY", self.initialPosition.y ) if cmds.objExists( self.animalName+".initialPositionZ" ) is False: cmds.addAttr( self.animalName, longName="initialPositionZ", defaultValue = 0.0, keyable = True ) cmds.setAttr( self.animalName+".initialPositionZ", self.initialPosition.z ) # Set objects position cmds.setAttr( self.animalName+".translateX", cmds.getAttr( self.animalName+".initialPositionX" ) ) cmds.setAttr( self.animalName+".translateY", cmds.getAttr( self.animalName+".initialPositionY" ) ) cmds.setAttr( self.animalName+".translateZ", cmds.getAttr( self.animalName+".initialPositionZ" ) ) # Create and set the initial heading if cmds.objExists( self.animalName+".initialHeading") is False: cmds.addAttr( self.animalName, longName = "initialHeading", defaultValue = 0.0, keyable = True ) cmds.setAttr( self.animalName+".initialHeading", self.initialHeading ) # Set objects y-axis rotation to its initial heading cmds.setAttr( self.animalName+".rotateY", cmds.getAttr( self.animalName+".initialHeading" ) ) # Create and set initial speed if cmds.objExists( self.animalName+".initialSpeed") is False: cmds.addAttr( self.animalName, longName = "initialSpeed", defaultValue = 0.5, keyable = True ) cmds.setAttr( self.animalName+".initialSpeed", self.initialSpeed ) # Create and set speed if cmds.objExists( self.animalName+".speed" ) is False: cmds.addAttr( self.animalName, longName = "speed", defaultValue=cmds.getAttr( self.animalName+".initialSpeed" ), keyable = True ) # Set the initial speed cmds.setAttr( self.animalName+".speed", cmds.getAttr( self.animalName+".initialSpeed" ) )
def makeAxis(origin, direction, cylinder_name="Cylinder", cone_name="Cone", cylinder_length=3, cylinder_size=0.025, cone_length=1, cone_size=0.1, shading_grp = ""): direct = direction/np.linalg.norm(direction) cylinder = cmds.polyCylinder(name=cylinder_name) cmds.scale(cylinder_size, cylinder_length, cylinder_size, cylinder) r = misc.getRotationFromAToB(a=np.matrix([0, 1, 0]).reshape(3, 1), b=np.matrix(direct).reshape(3, 1)) m = np.matrix(cmds.xform(cylinder, q=1, ws=1, m=1)).reshape(4, 4).transpose() m_new = np.matrix(np.r_[np.c_[r, [0, 0, 0]], [[0, 0, 0, 1]]]) * m cmds.xform(cylinder, m=m_new.transpose().A1, ws=1) cmds.move(origin[0], origin[1], origin[2], cylinder, absolute=True) cone = cmds.polyCone(name=cone_name) #shader grps if (shading_grp != ""): if not cmds.objExists(shading_grp): shading_grp = cmds.sets(renderable=True, noSurfaceShader=True, empty=True, name=shading_grp) else: if not cmds.objectType(shading_grp) == "shadingEngine": while (cmds.objExists(shading_grp)): shading_grp = "{0}1".format(shading_grp) shading_grp = cmds.sets(renderable=True, noSurfaceShader=True, empty=True, name=shading_grp) cmds.sets(cone[0], fe=shading_grp ) cmds.sets(cylinder[0], fe=shading_grp) #position and scale cmds.scale(cone_size, cone_length, cone_size, cone) m = np.matrix(cmds.xform(cone, q=1, ws=1, m=1)).reshape(4, 4).transpose() m_new = np.matrix(np.r_[np.c_[r, [0, 0, 0]], [[0, 0, 0, 1]]]) * m cmds.xform(cone, m=m_new.transpose().A1, ws=1) pos_cone = origin + (cylinder_length + cone_length) * direct cmds.move(pos_cone[0], pos_cone[1], pos_cone[2], cone, absolute=True) cmds.parent(cone[0], cylinder[0]) return cylinder, cone
def marker_geo_to_locator (_scale = 0.05): _sel = cmds.ls(selection=True) for _element in _sel: _cone = cmds.polyCone (sx=4, ch=False)[0] cmds.move (0,1,0, _cone+".scalePivot", _cone+".rotatePivot") cmds.move (0,0,0, _cone, rpr=True) cmds.setAttr (_cone+".scaleY", 0.5) cmds.makeIdentity(apply=True) _coneTop = cmds.duplicate(rr=True)[0] cmds.setAttr (_coneTop+".scaleY", -1) _marker = cmds.polyUnite (_cone, _coneTop, ch=False)[0] cmds.xform(_marker, scale=(_scale, _scale, _scale)) cmds.makeIdentity(apply=True) _pos = cmds.xform(_element, translation=True, query=True, worldSpace=True) cmds.xform(_marker, translation=_pos)
def createObjects(mode, numObjects=5): objList = [] for n in range(numObjects): if mode == "Cube": obj = cmds.polyCube() elif mode == "Sphere": obj = cmds.polySphere() elif mode == "Cylinder": obj = cmds.polyCylinder() elif mode == "Cone": obj = cmds.polyCone() else: cmds.error("I dont know what to create.") objList.append(obj[0]) cmds.select(objList)
def createObjects(mode , numObjects=5): """This creates cubes, sphere and cone""" onjList = [] #create a number of objects of the given geometry for n in range(numObjects): if mode == 'Cube': obj = cmds.polyCube() elif mode == 'Sphere': obj = cmds.polySphere() elif mode == 'Cone': obj = cmds.polyCone() else: cmds.error("Invalid geometry specified") objList.append(obj[0]) cmds.select(objList)
def fib_seq(): a, b = 0, 1 while b < limit: a, b = b, a + b cube = cmds.polyCone(h=10, r=10) # make a new brush cube cmds.move(b / 2, -b / 2, 0) #cut the sequence scale cmds.move(cube[0] + ".scalePivot", cube[0] + ".rotatePivot", absolute=True) # move pivit to origin cmds.select(cmds.listRelatives(cmds.ls(geometry=True), p=True, path=True), r=True) # select all geometry cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0) # freeze transforms cmds.rotate(0, rot, 0) # rotate all
def __init__(self): x=random.randint(0,14) y=0 z=random.randint(0,14) position = [x,y,z] while(pathfinding.point_on_obstacle(position)): x=random.randint(0,14) z=random.randint(0,14) position = [x,y,z] self.m_goal = position self.m_path = [[]] acone = cmds.polyCone() cmds.scale(20,20,20, acone) cmds.rotate( '90deg', 0, 0, acone ) cmds.rename( 'agent' ) self.m_cone = cmds.ls(sl=True) for cone in self.m_cone: # set the initial position cmds.addAttr(cone, longName="initialPositionX", defaultValue=0.0, keyable=True) cmds.setAttr(cone+".initialPositionX", position[0]) cmds.addAttr(cone, longName="initialPositionY", defaultValue=0.0, keyable=True) cmds.setAttr(cone+".initialPositionY", position[1]) cmds.addAttr(cone, longName="initialPositionZ", defaultValue=0.0, keyable=True) cmds.setAttr(cone+".initialPositionZ", position[2]) cmds.setAttr(cone+".translateX", cmds.getAttr(cone+".initialPositionX")) cmds.setAttr(cone+".translateY", cmds.getAttr(cone+".initialPositionY")) cmds.setAttr(cone+".translateZ", cmds.getAttr(cone+".initialPositionZ")) cmds.addAttr(cone, longName="initialHeading", defaultValue=0.0, keyable=True) cmds.setAttr(cone+".initialHeading", cmds.getAttr(cone+".rotateY")) cmds.setAttr(cone+".rotateY", cmds.getAttr(cone+".initialHeading")) # add speed attribute if we need it cmds.addAttr(cone, longName="initialSpeed", defaultValue=3.0, keyable=True) cmds.addAttr(cone, longName="speed", defaultValue=cmds.getAttr(cone+".initialSpeed"), keyable=True) #set the initial speed cmds.setAttr(cone+".speed", cmds.getAttr(cone+".initialSpeed"))
def make_choco(dis_): # 지난 만든 초고 거리 검사 def check_(sel_pos): # 수집된 좌표 looping for pos_ in collect_pos: # 거리 검사 if get_dis(pos_, sel_pos) < dis_: # 짧은 거리 True return return True # 짧은 거리 없으면, False return return False # 도넛의 모든 vtx 자표 수집 # q(query), ws(worldSpace), t(translation) all_pos = cmds.xform('pTorus1.vtx[*]', q=1, ws=1, t=1) # vtx (x, y, z) 로 정렬 all_vtx = zip(all_pos[::3], all_pos[1::3], all_pos[2::3]) # random 으로 섞기 전에 all_vtx 자료를 rand_vtx 로 복사 rand_vtx = copy.copy(all_vtx) # random 으로 섞기 random.shuffle(rand_vtx) # 수집할 자료 준비 collect_pos = [] # 섞은 자료 looping for sel_pos in rand_vtx: # 수집 자료 있으면, 거리 검사 if collect_pos: # 가까운 거리 있으면 계속 if check_(sel_pos): continue # 좌표 수집 collect_pos.append(sel_pos) # 수집된 좌표 looping for pos_ in collect_pos: # 좌표에 vtx 의 normal 추출 normal_ = cmds.polyNormalPerVertex('pTorus1.vtx[%s]' % all_vtx.index(pos_), query=True, xyz=True)[:3] # 초코 콘 만들기 cone_ = cmds.polyCone(axis=normal_, height=1, radius=0.5) # 좌표로 초코콘 이동 cmds.move(*list(pos_) + cone_[:1])
def createObjects(mode, numObjects=5): """This create objects. Supports Cubes, Spheres, Cylinder and Cones""" objList = [] # create a number of objects of the given type for n in range(numObjects): if mode == 'Cube': obj = cmds.polyCube() elif mode == 'Sphere': obj = cmds.polySphere() elif mode == 'Cylinder': obj = cmds.polyCylinder() elif mode == 'Cone': obj = cmds.polyCone() else: cmds.error("I don't know what to create") objList.append(obj[0]) return objList
def createObjects(mode, numObject): """ This create object, support Cubes, Spheres, Cylinders and Cones '""" objList = [] for n in range(numObject): if mode == 'Cube': obj = cmds.polyCube() elif mode == 'Sphere': obj = cmds.polySphere() elif mode == 'Cylinder': obj = cmds.polyCylinder() elif mode == 'Cone': obj = cmds.polyCone() else: cmds.error("I don't know what to create!") objList.append(obj[0]) cmds.select(objList) return objList
def createObject(mode, numObjects=5): objList = [] for n in range(numObjects): if mode == "Cube": obj = cmds.polyCube() elif mode == "Sphere": obj = cmds.polySphere() elif mode == "Cone": obj = cmds.polyCone() elif mode == "Cylinder": obj = cmds.polyCylinder() else: cmds.warning("Error!!") objList.append(obj[0]) cmds.select(objList) return objList
def createCone(locName): cone = mc.polyCone(name=locName + '_cone', r=1, h=2, sx=4, sy=1, sz=0, ax=[0, -1, 0], rcp=0, cuv=3, ch=True)[0] mc.move(1, y=True) mc.rotate(45, y=True) mc.move(0, 0, 0, cone + ".scalePivot", cone + ".rotatePivot", absolute=True) mc.makeIdentity(apply=True, translate=True, rotate=True) return cone
def marker_geo_to_locator (_scale = 0.05): selection = cmds.ls(selection=True) markers = [] for element in selection: cone = cmds.polyCone( sx = 4, ch = False)[0] cmds.move( 0, 1, 0, cone + ".scalePivot", cone + ".rotatePivot") cmds.move( 0, 0, 0, cone, rpr = True) cmds.setAttr( cone + ".scaleY", 0.5) cmds.makeIdentity( apply = True) coneTop = cmds.duplicate( rr = True)[0] cmds.setAttr( coneTop + ".scaleY", -1) marker = cmds.polyUnite( cone, coneTop, ch = False)[0] cmds.xform( marker, scale = (scale, scale, scale)) cmds.makeIdentity( apply = True) pos = cmds.xform( element, translation = True, query = True, worldSpace = True) cmds.xform( marker, translation = pos) markers.append( marker) cmds.select( markers, replace = True) cmds.group( name = 'survey_markers_geo_to_3De')
def setShapeLook(objname,scale,position,rotation,shapeobj,parent): #sets object shape. input takes Name,Scale,Position,Rotation,what shape it is, and who is it's parent. if (shapeobj is "Cube"): # if it is a cube, it makes a cube obj = cmds.polyCube(name = objname)[0] elif (shapeobj is "Sphere"): obj = cmds.polySphere(name = objname)[0] elif (shapeobj is "Cylinder"): obj = cmds.polyCylinder(name = objname)[0] elif (shapeobj is "Cone"): obj = cmds.polyCone(name = objname)[0] cmds.scale(scale[0],scale[1],scale[2],obj) #sets scale cmds.move(position[0],position[1],position[2],obj) #sets position if(rotation is "none"): #if there is rotation or not pass else: cmds.rotate(rotation[0],rotation[1],rotation[2],obj) #sets rotation cmds.makeIdentity(obj,a=1,r=1,s=1,t=1) #freezes all transforms if (parent is "none"): #if there is a parent or not pass else: cmds.parent(obj,parent) #sets parent print "Set Look of " + objname + ", which is a " + shapeobj + ", and parented it to " + parent + "." #writes a message of what it did.
def createMarker(s, target, name, shape=None, colour=None): sel = cmds.ls(sl=True) name = "%s_marker" % name if cmds.objExists(name): cmds.delete(name) if shape == "square": name = cmds.polyCube(name=name)[0] elif shape == "cone" : name = cmds.polyCone(name=name)[0] elif shape == "cylinder": name = cmds.polyCylinder(name=name)[0] else: name = cmds.polySphere(name=name)[0] cmds.parent(name, s.baseName) for at in [".sx", ".sy", ".sz"]: cmds.connectAttr("%s.markerSize" % s.baseName, name + at, f=True) cmds.parentConstraint(target, name) cmds.setAttr("%s.overrideEnabled" % name, 1) cmds.setAttr("%s.overrideDisplayType" % name, 2) cmds.polyColorPerVertex(name, rgb=colour or [1,1,0], cdo=True) cmds.select(sel, r=True)
def setTeeth(amount,scale,position,offset,roof=True): #function that sets the teeth. for i in range(amount): # a loop that will make teeth based on how many there is (amount) tooth = cmds.polyCone(name = 'Teeth1')[0] #sets tooth to cone shape cmds.scale(scale[0],scale[1],scale[2],tooth) #sets scale if (roof): #if roof is true, it will execute this block cmds.rotate(180,0,0,tooth) #flips tooth over if(amount is TopFrontTeethAmount):# if it is top and front of mouth cmds.move(position[0],position[1],position[2]-(offset*i),tooth) #simple math of offsetting each tooth by number of teeth chosen elif(amount is TopSideTeethAmount): #if tooth is side cmds.move(position[0] - offset*(i/2), position[1], position[2]*((-1)**i), tooth) #the i is also used as an exponent to make the second one of every pair mirror the first #also flips every other tooth cmds.parent(tooth,"Head") #parents tooth to head print "Made a top tooth number." #prints message else: if (amount is BottomFrontTeethAmount): cmds.move(position[0],position[1],position[2]-(offset*i),tooth) elif(amount is BottomSideTeethAmount): cmds.move(position[0] + offset*(i/2), position[1], position[2]*((-1)**i), tooth) cmds.parent(tooth,"Jaw") print "Made a bottom tooth."
def applyCallback(pNumberBlades, pXSpaceLower, pXSpaceUpper, pZSpaceLower, pZSpaceUpper, pAverageHeight, *pArgs): ''' This function generates the grass using the inputs from the user. ''' random.seed(100) #creating initial blade of grass startR = 0.1 startH = 1 result = cmds.polyCone(r=startR, h=startH, name='OGCone#') coneGroup = cmds.group(empty=True, name="coneGroup") #retreiveing data inputed by user XSpaceLower = cmds.intField(pXSpaceLower, query=True, value=True) XSpaceUpper = cmds.intField(pXSpaceUpper, query=True, value=True) ZSpaceLower = cmds.intField(pZSpaceLower, query=True, value=True) ZSpaceUpper = cmds.intField(pZSpaceUpper, query=True, value=True) NumberBlades = cmds.intField(pNumberBlades, query=True, value=True) AverageHeight = cmds.intField(pAverageHeight, query=True, value=True) #generating grass based on user inputs for i in range(0, int(NumberBlades)): x = random.uniform(XSpaceLower, XSpaceUpper) z = random.uniform(ZSpaceLower, ZSpaceUpper) #scaling each blade to have slight variations in radii and height randR = random.uniform(0.05, 0.3) randY = random.uniform(0.8, 1.1) resInstance = cmds.instance(result[0], name='cone#') cmds.scale(randR, randY * AverageHeight, randR, resInstance) #moving all the blades up so that they are bottom aligned with the xz plane moveToOriginY = (startH * randY * AverageHeight) / 2 cmds.move(x, moveToOriginY, z, resInstance) cmds.parent(resInstance, coneGroup) #hiding the initial blade cmds.hide(result) cmds.xform(coneGroup, centerPivots=True)
def stalagmiteRock(self, nameGroup, rocks, radiusDistr, minScale, maxScale): """Creates the requested stalagmite style rocks""" rocksGroup = cmds.group(empty=True, name=nameGroup) for r in range(rocks): xPos = random.uniform(-radiusDistr, radiusDistr) zPos = random.uniform(-radiusDistr, radiusDistr) list1 = (2, 3, 4, 5, 6, 7, 8) list2 = (3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15) list3 = (4, 5, 6, 7, 8) radius = random.choice(list1) height = random.choice(list2) sx = random.choice(list3) sy = random.choice(list3) xLT = random.uniform(-0.3, 0.3) yLT = random.uniform(-0.3, 0.3) zLT = random.uniform(-0.3, 0.3) rock = cmds.polyCone(name="stalagmite#", radius=radius, height=height, sx=sx, sy=sy) cmds.parent(rock, rocksGroup) cmds.xform(rock, piv=(0, -(height / 2), 0), ws=True) cmds.move(xPos, height / 2, zPos) polyVtx = cmds.polyMoveVertex(ch=True, ran=3.0, lt=(xLT, yLT, zLT)) rockScale = random.uniform((minScale * 0.25), (maxScale * 0.25)) cmds.select(rock) cmds.scale(rockScale, rockScale, rockScale) cmds.polySmooth(dv=1) cmds.delete(ch=True)
def create(self): handle = cmds.polyCylinder(sc=0, r=0.05, sa=5) arrowCone = cmds.polyCone(r=.25, h=.5, sa=5) cmds.move(0, 1.2, 0) arrow = cmds.polyUnite(handle[0], arrowCone[0]) arrow = cmds.rename(arrow[0], 'arrowMesh#') self.__arrowMesh = arrow cmds.DeleteHistory() topVertices = [] botVertices = [] selList = om.MSelectionList() selList.add(arrow) # meshFn = om.MFnMesh(selList.getDagPath(0)) # for i in range(meshFn.numVertices): # point = meshFn.getPoint(i, om.MSpace.kWorld) vertIt = om.MItMeshVertex(selList.getDagPath(0)) while not vertIt.isDone(): pos = vertIt.position(om.MSpace.kWorld) if pos.y > 0: topVertices.append(vertIt.index()) else: botVertices.append(vertIt.index()) vertIt.next() topVert = ['{}.vtx[{}]'.format(arrow, id) for id in topVertices] botVert = ['{}.vtx[{}]'.format(arrow, id) for id in botVertices] self.topHandle = cmds.cluster(topVert)[1] self.botHandle = cmds.cluster(botVert)[1] self.topHandle = cmds.rename(self.topHandle, 'arrowTopHandle#') self.botHandle = cmds.rename(self.botHandle, 'arrowbotHandle#')
def fountainTop(fountain): ''' Creates a top decoration for a fountain. fountain: A object the top decoration will be placed on. On exit: A top decoration has been created by adding a deformer to a basic polygonal object. The top is returned as a tuple with the object name and node name. ''' height = random.uniform(0.1,0.6) # Decide which type of object will form the top. type = random.choice(["cube", "cylinder", "prism", "cone", "sphere"]) if type == "cube": top = cmds.polyCube(name = "top", h = height, w = 0.2, d = 0.2, sy = 10) if type == "cylinder": top = cmds.polyCylinder(name = "top",h = height, r = 0.1, sy = 10) if type == "prism": top = cmds.polyPrism(name = "top", l = height, w = 0.1, sh = 10) if type == "cone": top = cmds.polyCone(name = "top", h = height, r = 0.1, sy = 10) if type == "sphere": top = cmds.polySphere(name = "top",r = height/2.0) bbox = cmds.exactWorldBoundingBox(fountain) cmds.xform(top, translation = (0,bbox[4]+ height/2.0,0)) flare = random.choice([0,1]) if flare == 1: cmds.select(top[0]) flare = cmds.nonLinear(type = "flare") cmds.setAttr(flare[0] + ".curve", random.uniform(-3,3)) twist = random.choice([0,1]) if type == "cube" or type == "prism": if twist == 1: cmds.select(top[0]) twist = cmds.nonLinear(type = "twist") cmds.setAttr(twist[0] + ".endAngle", random.randint(-500, 500)) return top
from maya import cmds for i in range(4): obj = cmds.polyCylinder(name="pCy1") # 오브젝트 명 지정 해주면서 생성 cmds.setAttr(obj[0] + ".s", 3, 0.2, 3) cmds.setAttr(obj[0] + ".rx", 90) # 해당 오브젝트 x, y, z 값 변경 cmds.setAttr("pCy2.t", -10, 0, 0) cmds.setAttr("pCy3.t", -10, 0, 5) cmds.setAttr("pCy4.t", 0, 0, 5) cmds.polyCube(name="Cube") cmds.setAttr("Cube.s", 10, 0.5, 5) cmds.setAttr("Cube.t", -5, 0, 2.5) cmds.polyCone(name="Cone") cmds.setAttr("Cone.scale", 1, 3, 1) cmds.setAttr("Cone.t", -1, 3, 2.5) cmds.setAttr("Cone.rz", -30)
sumZ=0 #4 vertices (12_all_coordinates / 3_coordinates_each vertex in 3d) faceVertices=len(facepositionWS)/3 vertexElements=3 #print "faceVertices=%d"%(faceVertices) for v in range(0,len(facepositionWS),vertexElements): sumX=sumX + facepositionWS[v] sumY=sumY + facepositionWS[v+1] sumZ=sumZ + facepositionWS[v+2] #average position of vertices of each faces faceCenter = [sumX/faceVertices, sumY/faceVertices, sumZ/faceVertices] #place cone c=cmds.polyCone( n='myCone', sx=5, sy=5, sz=5) cmds.move( faceCenter[0], faceCenter[1], faceCenter[2], c, absolute=True ) cmds.scale(0.3,0.3,0.3, c, absolute=True) #split polyinfo unicode , to get normals of each face #fnormal= [] #label, vertex, x, y, z = facenormals[i].split() #fnormal.append(float(x)) #fnormal.append(float(y)) #fnormal.append(float(z)) fnormal=planeNormal fnormalNormalized=[] #normalize vector from point on sphee to origin of sphere mag=math.sqrt( fnormal[0]*fnormal[0] + fnormal[1]*fnormal[1] + fnormal[2]*fnormal[2] )
cmds.setAttr(('%s.incandescence' % new_shade), R, G, B, type='double3', edit=True) cmds.setAttr(('%s.color' % new_shade), R, G, B, type='double3') # loop all the selected locator and place a cone on op of it for obj in locator_sele: # Creating a cone and adding that under the cone_group cone_new_t, cone_new_s = cmds.polyCone(r=1, h=3.3, sa=3, name='%s_%s' % (obj, 'Cone#')) cmds.parent(cone_new_t, cone_grp) cone_transform.append(cone_new_t) cone_shape.append(cone_new_s) # Bringing the pivot of the cone in to its own tip cone_vtx = cmds.ls('%s.vtx[*]' % (cone_new_t), fl=True) cone_tip = cone_vtx[-1] vtx_pos = cmds.xform(cone_tip, ws=1, q=1, t=1) cmds.move( vtx_pos[0], vtx_pos[1], vtx_pos[2], ['%s.scalePivot' % (cone_new_t), '%s.rotatePivot' % (cone_new_t)],
def applyCallback(pWidth, pLength, pDensity, pLeafLength, pBranchLayers, pBranchAngle, pTrunkHeight, pTrunkConeAngle, pTrunkConeSize, *pArgs): ''' This is a function that constructs the palm tree out of cones and cylinders. The branches are formed using the equation of a parabola ''' Width = cmds.intSlider(pWidth, query=True, value=True) Length = cmds.intSlider(pLength, query=True, value=True) Density = cmds.intSlider(pDensity, query=True, value=True) LeafLength = cmds.floatSlider(pLeafLength, query=True, value=True) BranchLayers = cmds.intSlider(pBranchLayers, query=True, value=True) BranchAngle = cmds.intSlider(pBranchAngle, query=True, value=True) TrunkHeight = cmds.intSlider(pTrunkHeight, query=True, value=True) TrunkConeAngle = cmds.intSlider(pTrunkConeAngle, query=True, value=True) TrunkConeSize = cmds.floatSlider(pTrunkConeSize, query=True, value=True) #intializing shapes that will be used for the leaves and branches cones = cmds.polyCone(r=0.5, h=0.5, name='cone') cones2 = cmds.polyCone(r=0.5, h=0.5, name='cones2') cyl = cmds.polyCylinder(r=0.05, h=0.26, name='original#') cylGroup = cmds.group(empty=True, name="Group") cmds.move(0, -0.25, 0, "cone.scalePivot", "cone.rotatePivot", absolute=True) cmds.scale(0.2, -LeafLength, 0.01, cones) cmds.scale(0.2, 0.4, 0.01, cones2) cmds.move(0, 0.15, 0, cones) #creating the group for one leaf leafGroup = cmds.group(empty=True, name="leafGroup") cmds.move(0, 0.1, 0, "leafGroup.scalePivot", "leafGroup.rotatePivot", absolute=True) cmds.parent(cones, leafGroup) cmds.parent(cones2, leafGroup) coneGroup = cmds.group(empty=True, name="Group") #producing multiple leaves along a curve tapperLeaf = 0.9 for i in range(0, Length): resInstance = cmds.instance(leafGroup, name='instance#') resInstance2 = cmds.instance(leafGroup, name='instance#') cmds.move(0, -(1.0 / Width) * ((0.2 * float(i))**2), 0.2 * float(i), resInstance) cmds.rotate(-40, 0, -50, resInstance) cmds.move(0, -(1.0 / Width) * ((0.2 * float(i + 0.5))**2), 0.2 * float(i + 0.5), resInstance2) cmds.rotate(-40, 0, 50, resInstance2) #tappering the length of the leaf in the second half of it if i > (Length - Length / 2.0): cmds.scale(1, tapperLeaf, 1, resInstance) cmds.scale(1, tapperLeaf, 1, resInstance2) if i % 2 == 0: tapperLeaf -= 0.1 #making sure that the tapperLeaf variable does not get too small/negative if tapperLeaf < 0.3: tapperLeaf += 0.1 cmds.parent(resInstance, coneGroup) cmds.parent(resInstance2, coneGroup) cmds.delete(leafGroup) #producing the branch along a curve tapper = 0.9 for j in range(0, 2 * Length): resInstance3 = cmds.instance(cyl, name='instance#') cmds.move(0, -(1.0 / Width) * ((0.1 * float(j))**2) + 0.05, 0.1 * float(j) + 0.1, resInstance3) #calculating the arc tangent of the derative to get degrees by which the segments need to be rotated #so that they lie tanget to the curve derivative = -(2.0 / Width) * (0.1 * float(j)) angleRadDer = math.atan(derivative) angleDegDer = ((angleRadDer) * 180.0) / 3.14159 cmds.rotate(90 - angleDegDer, 0, 0, resInstance3) #tappering the branch if j > (2 * Length - 5): cmds.scale(tapper, 1, tapper, resInstance3) tapper -= 0.1 cmds.parent(resInstance3, cylGroup) cmds.delete(cyl) branchGroup = cmds.group(empty=True, name="branchGroup") cmds.parent(cylGroup, branchGroup) cmds.parent(coneGroup, branchGroup) #creating multiple layer of rotated branches allBranchGroup = cmds.group(empty=True, name="allbranchGroup") for k in range(0, Density): angle = -BranchAngle for c in range(0, BranchLayers): groupInstance = cmds.instance(branchGroup, name='groupinstance#') cmds.rotate(angle, (360 / Density) * k + (30 * c), 0, groupInstance) cmds.parent(groupInstance, allBranchGroup) if angle > (-120): angle -= 90.0 / BranchLayers cmds.delete(branchGroup) trunk = cmds.polyCylinder(r=0.2, h=TrunkHeight, name='trunk') cmds.move(0, TrunkHeight / 2.0, 0, trunk) cmds.move(0, TrunkHeight, 0, allBranchGroup) trunkCones = cmds.polyCone(r=0.3, h=0.5, name='trunkCones') cmds.scale(TrunkConeSize, 1, TrunkConeSize, trunkCones) cmds.move(0, 0.25, 0, trunkCones) cmds.move(0, 0, 0, "trunkCones.scalePivot", "trunkCones.rotatePivot", absolute=True) #creating one layer of trunk cones trunkConesGroup = cmds.group(empty=True, name="trunkConesGroup") for a in range(0, 4): trunkConeInstance = cmds.instance(trunkCones, name='trunkconeinstance#') cmds.rotate(TrunkConeAngle, 0, (360 / 3) * a, trunkConeInstance) cmds.parent(trunkConeInstance, trunkConesGroup) cmds.delete(trunkCones) cmds.rotate(-90, 0, 0, trunkConesGroup) cmds.move(0, -0.25, 0, trunkConesGroup) #creating the trunk fullTrunk = cmds.group(empty=True, name="fullTrunk") for b in range(0, int(7 * TrunkHeight)): trunkConeGroupInstance = cmds.instance(trunkConesGroup, name='trunkConeGroupInstance#') cmds.move(0, 0.15 * b, 0, trunkConeGroupInstance) if b % 2 == 0: cmds.rotate(-90, 60, 0, trunkConeGroupInstance) if b < (6.4 * TrunkHeight) / 2.0: cmds.select(trunkConeGroupInstance[0], r=True) scaleFactor = ((7 * TrunkHeight) - b) * (2.0 / (7 * TrunkHeight)) cmds.scale(scaleFactor, scaleFactor, scaleFactor, trunkConeGroupInstance) cmds.parent(trunkConeGroupInstance, fullTrunk) cmds.delete(trunkConesGroup)
import maya.cmds as cmds from math import * psphere = cmds.sphere(r=5) pcube = cmds.polyCube() pcone = cmds.polyCone() closestToSurface = cmds.createNode("closestPointOnSurface") cmds.connectAttr(closestToSurface + '.position', pcube[0] + '.translate') cmds.connectAttr(pcone[0] + '.translate', closestToSurface + '.inPosition') cmds.connectAttr(psphere[0] + '.worldSpace[0]', closestToSurface + '.inputSurface')
#4 vertices (12_all_coordinates / 3_coordinates_each vertex in 3d) faceVertices = len(facepositionWS) / 3 vertexElements = 3 #print "faceVertices=%d"%(faceVertices) for v in range(0, len(facepositionWS), vertexElements): sumX = sumX + facepositionWS[v] sumY = sumY + facepositionWS[v + 1] sumZ = sumZ + facepositionWS[v + 2] #average position of vertices of each faces faceCenter = [ sumX / faceVertices, sumY / faceVertices, sumZ / faceVertices ] #place cone c = cmds.polyCone(n='myCone', sx=5, sy=5, sz=5) cmds.move(faceCenter[0], faceCenter[1], faceCenter[2], c, absolute=True) cmds.scale(0.3, 0.3, 0.3, c, absolute=True) #split polyinfo unicode , to get normals of each face #fnormal= [] #label, vertex, x, y, z = facenormals[i].split() #fnormal.append(float(x)) #fnormal.append(float(y)) #fnormal.append(float(z)) fnormal = planeNormal fnormalNormalized = [] #normalize vector from point on sphee to origin of sphere mag = math.sqrt(fnormal[0] * fnormal[0] + fnormal[1] * fnormal[1] +
def polyCone(*args, **kwargs): res = cmds.polyCone(*args, **kwargs) if not kwargs.get('query', kwargs.get('q', False)): res = _factories.maybeConvert(res, _general.PyNode) return res
def drawLine(self): """ draw line between two position """ if self.position0 == None or self.position1 == None: om.MGlobal.displayError("please specify the two position") return #create curve CRV = cmds.curve( d=1, p=[self.position0, self.position1], k=[0, 1], n= self.side + "_"+ self.moduleName + "_" + "CRV") #create cone and move pivot cone = cmds.polyCone(ch=False, o=True, r=0.05, h=0.1, cuv=3, n= self.side + "_"+ self.moduleName + "_" + "GEO") cmds.move(0, 0.05, 0, cone[0] + ".scalePivot", r=True ) cmds.move(0, 0.05, 0, cone[0] + ".rotatePivot", r=True ) objs = [CRV, cone] for obj in objs: shapeNodes = cmds.listRelatives(obj, shapes=True) for shape in shapeNodes: try: cmds.setAttr("{0}.overrideEnabled".format(shape), True) cmds.setAttr("{0}.overrideColor".format(shape), self.colorIndex) except: om.MGlobal.displayWarning("Failed to override color: {0}".format(shape)) #create cluster both end for i in range(2): clusterName = name.uniqueName(self.side + "_"+ self.moduleName + "_" + "CLT") clusters = cmds.cluster("%s.cv[%d]" % (CRV,i), n= self.side + "_"+ clusterName + "_" + "CLT" ) print clusters cmds.setAttr("%s.visibility" % clusters[1], 0) self.cluster.append(clusters[1]) #create locator startLoc = cmds.spaceLocator(p=(0, 0, 0), n= self.side + "_"+ self.moduleName + "_" + "LOC") cmds.move(self.position0[0], self.position0[1], self.position0[2], startLoc) endLoc = cmds.spaceLocator(p=(0, 0, 0), n= self.side + "_"+ self.moduleName + "_" + "LOC") cmds.move(self.position1[0], self.position1[1], self.position1[2], endLoc) #create annotation annotation = cmds.annotate( endLoc, tx='position:%s' % `self.position1`, p=self.position1) annotation = cmds.listRelatives(annotation, p=True) annotation = cmds.rename(annotation, self.side + "_"+ self.moduleName + "_" + "ANT") shape = cmds.listRelatives(annotation, shapes=True) cmds.setAttr("{0}.overrideEnabled".format(shape[0]), True) cmds.setAttr("{0}.overrideColor".format(shape[0]), self.colorIndex) #create point locator cmds.pointConstraint(startLoc, self.cluster[0], offset=(0, 0, 0), weight=1, mo=False) cmds.pointConstraint(endLoc, self.cluster[1], offset=(0, 0, 0), weight=1, mo=False) cmds.pointConstraint(endLoc, annotation, offset=(0, 0, 0), weight=1, mo=False) cmds.pointConstraint(self.cluster[1], cone, offset=(0, 0, 0), weight=1, mo=False) cmds.aimConstraint(self.cluster[0], cone, offset=(0, 0, 0), weight=1, aimVector=(0, -1, 0), upVector=(0, 1, 0), worldUpType="vector", worldUpVector=(0, 1, 0)) #parenting cmds.parent(endLoc, startLoc) cmds.parent(annotation, startLoc) cmds.parent(self.cluster[0], startLoc) cmds.parent(self.cluster[1], startLoc) cmds.parent(cone, startLoc) cmds.parent(startLoc, self.groupNode) cmds.parent(CRV, self.groupNode) #cleanup attribute.lockAndHide(CRV, ['t', 'r', 's', 'v'], False) cmds.setAttr("RIG_GRP.overrideDisplayType", 0) cmds.setAttr(endLoc[0] + ".visibility", 0) return startLoc, endLoc
# Creates group for the newly created cones inside the locator parent group & Making a child of the parent group. # OR # Creates a free group in outliner if there are no parent group available for locator if x == 2: cone_grp = cmds.group(em=True, name='%s_cone' % root_grp, parent=root_grp) else: cone_grp = cmds.group(em = True, name = 'cone_Group') # loop all the selected locator and place a cone on op of it for obj in locator_sele: # Making a cone and adding that under the cone_group cone_new = cmds.polyCone(r = 1, h = 3.3, name = '%s_%s' % (obj, 'Cone') ) cmds.parent('%s_%s' % (obj, 'Cone'), cone_grp) if cmds.objExists('lambertA'): shaderSG = cmds.sets(name = 'lambertASG', em = 1, renderable = 1, noSurfaceShader = 1) cmds.connectAttr('lambertA.outColor', '%s.surfaceShader' % shaderSG) cmds.sets(cone_new, e=1, forceElement = shaderSG) else: myshade = cmds.shadingNode('lambert', name = 'lambertA', asShader = True)
def build(count=3, driver_axis=1, max_size=3, min_size=0.1): """ build the driver node, target nodes, and wire them up """ # build driver drvr = cmds.polyCone(radius=0.5, height=1.0, name='driver')[0] cmds.xform(drvr, ro=[90, 0, 0]) # vectorProduct to isolate driver_axis from driver's worldmatrix vp_drv = cmds.createNode('vectorProduct', name='vpn_driver') cmds.setAttr(vp_drv + '.operation', 3) # vector Matrix Product cmds.setAttr(vp_drv + '.normalizeOutput', 1) cmds.setAttr(vp_drv + '.input1' + ['X', 'Y', 'Z'][driver_axis], 1.0) # isolate driver axis as output vector cmds.connectAttr(drvr + '.worldMatrix', vp_drv + '.matrix') # vectorProduct to get driver translate vp_drv_pos = cmds.createNode('vectorProduct', name='vpn_driver') cmds.setAttr(vp_drv_pos + '.operation', 3) # vector Matrix Product cmds.connectAttr(drvr + '.worldMatrix', vp_drv_pos + '.matrix') for i in range(count): target = cmds.polySphere(radius=0.25)[0] cmds.xform(target, ws=1, t=[((0.5 - random.random()) * 10), 0, ((0.5 - random.random()) * 10) ]) # just on xz plane to test # decomposeMatrix to get target translate dm_target = cmds.createNode('decomposeMatrix', name='dmn_' + target) cmds.connectAttr(target + '.worldMatrix', dm_target + '.inputMatrix') # get vector between driver and target pma_target = cmds.createNode('plusMinusAverage', name='pma_' + target) cmds.setAttr(pma_target + '.operation', 2) #subtract cmds.connectAttr(dm_target + '.outputTranslate', pma_target + '.input3D[0]') cmds.connectAttr(vp_drv_pos + '.output', pma_target + '.input3D[1]') # normalize driver-target vector vp_norm = cmds.createNode('vectorProduct', name='vp_norm_' + target) cmds.setAttr(vp_norm + '.operation', 0) cmds.setAttr(vp_norm + '.normalizeOutput', 1) cmds.connectAttr(pma_target + '.output3D', vp_norm + '.input1') # dot product vp_dot = cmds.createNode('vectorProduct', name='vp_dot_' + target) cmds.setAttr(vp_dot + '.operation', 1) cmds.setAttr(vp_dot + '.normalizeOutput', 1) cmds.connectAttr(vp_drv + '.output', vp_dot + '.input1') cmds.connectAttr(vp_norm + '.output', vp_dot + '.input2') # clamp output with setRange node sr_target = cmds.createNode('setRange', name='srn_' + target) cmds.setAttr(sr_target + '.minX', min_size) cmds.setAttr(sr_target + '.maxX', max_size) cmds.setAttr(sr_target + '.oldMinX', 0) cmds.setAttr(sr_target + '.oldMaxX', 1) cmds.connectAttr(vp_dot + '.outputX', sr_target + '.valueX') # connect to target scale for axis in ['X', 'Y', 'Z']: cmds.connectAttr(sr_target + '.outValueX', target + '.scale' + axis)
def __init__(self, width, height): super(ConeBuilding, self).__init__(width, height) self.polyCone = cmds.polyCone(radius=self.width//2, h=self.height)
def add_antenna(self, x, y, z): """Add cone-shaped antenna to building""" antenna = cmds.polyCone(r=.2, h=2) cmds.move(x, y, z)
def cone(**kwargs): try: return cmds.polyCone(**kwargs)[1] except: raise
import maya.cmds as mc myHight = 2 myCube = mc.polyCube(w= 2, h=myHight, d=2, n="Cube") mc.move(0,myHight/2.0,0,myCube, r=True) mc.rotate(0,0,0,myCube, r=True) myCone = mc.polyCone(n="Pyramid") mc.move(-5,myHight/2.0,0,myCone, r=True) mc.rotate(0,0,0,myCone, r=True) myCylinder = mc.polyCylinder(n="Cylinder") mc.move(-10,myHight/2.0,0,myCylinder, r=True) mc.rotate(0,0,0,myCylinder, r=True)
def make_cone( cls ): mc.polyCone()
def doIt(self, argList): # get only the first object from argument list try: obj = misc.getArgObj(self.syntax(), argList)[0] except: cmds.warning("No object selected!") return if (cmds.objectType(obj) != 'transform'): cmds.error("Object is not of type transform!") return # parameter list argData = om.MArgParser (self.syntax(), argList) axisOrder = argData.flagArgumentString('axisOrder', 0) if (argData.isFlagSet('axisOrder')) else "yzx" fast = argData.flagArgumentBool('fast', 0) if (argData.isFlagSet('fast')) else True # build x-axis from cylinder and cone xCyl = cmds.polyCylinder(n = "xCyl", ax = [1,0,0], r = 0.05, h = 10, sx = 10) xCone = cmds.polyCone(n = "xCone", ax = [1,0,0], r = 0.15, h = 0.4) cmds.xform(xCone, t = [5,0,0]) # combine both object xAxis = cmds.polyUnite(xCyl, xCone, ch = 0, n = "x") # create y and z axes by duplicating x axis yAxis = cmds.duplicate(xAxis, n = "y") zAxis = cmds.duplicate(xAxis, n = "z") cmds.xform(yAxis, ro = [0,0,90]) cmds.xform(zAxis, ro = [0,-90,0]) # freeze rotation of y-axis and z-axis cmds.makeIdentity(yAxis, a = 1, r = 1) cmds.makeIdentity(zAxis, a = 1, r = 1) # create space locator at the origin point (NOT necessary any more because of grouping) #origin = cmds.spaceLocator(n = "origin") # create shading nodes for each axis (x = red, y = green, z = blue) if (len(cmds.ls('xAxis', type = 'lambert'))): lx = cmds.ls('xAxis', type = 'lambert')[0] else: lx = cmds.shadingNode('lambert', asShader = 1, n = 'xAxis') cmds.setAttr(lx + '.color', 1, 0, 0, type = 'double3') if (len(cmds.ls('yAxis', type = 'lambert'))): ly = cmds.ls('yAxis', type = 'lambert')[0] else: ly = cmds.shadingNode('lambert', asShader = 1, n = 'yAxis') cmds.setAttr(ly + '.color', 0, 1, 0, type = 'double3') if (len(cmds.ls('zAxis', type = 'lambert'))): lz = cmds.ls('zAxis', type = 'lambert')[0] else: lz = cmds.shadingNode('lambert', asShader = 1, n = 'zAxis') cmds.setAttr(lz + '.color', 0, 0, 1, type = 'double3') # select each axis and assign shader node cmds.select(xAxis) cmds.hyperShade(assign = lx) cmds.select(yAxis) cmds.hyperShade(assign = ly) cmds.select(zAxis) cmds.hyperShade(assign = lz) # group all object #cs = cmds.group(xAxis, yAxis, zAxis, n = "CS") cs = cmds.polyUnite(xAxis, yAxis, zAxis, ch = 0, n = "CS") # make sure pivots are in origin cmds.xform(cs, piv = [0,0,0]) # calculate alignment of given object to set coordinate system inside transform node rotM = np.matrix(cmds.alignObj(obj, ao = axisOrder, f = fast)).reshape(4,4) # transpose matrix and set center point for translation rotM = rotM.transpose().getA1().tolist() rotM[12:15] = cmds.centerPoint(obj) cmds.xform(cs, m = rotM) # set transform node as parent of the new coordinate system cmds.parent(cs, obj) # activate rotate tool cmds.RotateTool() self.setResult(cs)
def _polyCone(self): cmds.polyCone()
def create_cone(*args, **kwargs): print "create my cone" cmds.polyCone()
def drawLine(self): """ draw line between two position """ if self.position0 == None or self.position1 == None: om.MGlobal.displayError("please specify the two position") return #create curve CRV = cmds.curve(d=1, p=[self.position0, self.position1], k=[0, 1], n=self.side + "_" + self.moduleName + "_" + "CRV") #create cone and move pivot cone = cmds.polyCone(ch=False, o=True, r=0.05, h=0.1, cuv=3, n=self.side + "_" + self.moduleName + "_" + "GEO") cmds.move(0, 0.05, 0, cone[0] + ".scalePivot", r=True) cmds.move(0, 0.05, 0, cone[0] + ".rotatePivot", r=True) objs = [CRV, cone] for obj in objs: shapeNodes = cmds.listRelatives(obj, shapes=True) for shape in shapeNodes: try: cmds.setAttr("{0}.overrideEnabled".format(shape), True) cmds.setAttr("{0}.overrideColor".format(shape), self.colorIndex) except: om.MGlobal.displayWarning( "Failed to override color: {0}".format(shape)) #create cluster both end for i in range(2): clusterName = name.uniqueName(self.side + "_" + self.moduleName + "_" + "CLT") clusters = cmds.cluster("%s.cv[%d]" % (CRV, i), n=self.side + "_" + clusterName + "_" + "CLT") print clusters cmds.setAttr("%s.visibility" % clusters[1], 0) self.cluster.append(clusters[1]) #create locator startLoc = cmds.spaceLocator(p=(0, 0, 0), n=self.side + "_" + self.moduleName + "_" + "LOC") cmds.move(self.position0[0], self.position0[1], self.position0[2], startLoc) endLoc = cmds.spaceLocator(p=(0, 0, 0), n=self.side + "_" + self.moduleName + "_" + "LOC") cmds.move(self.position1[0], self.position1[1], self.position1[2], endLoc) #create annotation annotation = cmds.annotate(endLoc, tx='position:%s' % ` self.position1 `, p=self.position1) annotation = cmds.listRelatives(annotation, p=True) annotation = cmds.rename( annotation, self.side + "_" + self.moduleName + "_" + "ANT") shape = cmds.listRelatives(annotation, shapes=True) cmds.setAttr("{0}.overrideEnabled".format(shape[0]), True) cmds.setAttr("{0}.overrideColor".format(shape[0]), self.colorIndex) #create point locator cmds.pointConstraint(startLoc, self.cluster[0], offset=(0, 0, 0), weight=1, mo=False) cmds.pointConstraint(endLoc, self.cluster[1], offset=(0, 0, 0), weight=1, mo=False) cmds.pointConstraint(endLoc, annotation, offset=(0, 0, 0), weight=1, mo=False) cmds.pointConstraint(self.cluster[1], cone, offset=(0, 0, 0), weight=1, mo=False) cmds.aimConstraint(self.cluster[0], cone, offset=(0, 0, 0), weight=1, aimVector=(0, -1, 0), upVector=(0, 1, 0), worldUpType="vector", worldUpVector=(0, 1, 0)) #parenting cmds.parent(endLoc, startLoc) cmds.parent(annotation, startLoc) cmds.parent(self.cluster[0], startLoc) cmds.parent(self.cluster[1], startLoc) cmds.parent(cone, startLoc) cmds.parent(startLoc, self.groupNode) cmds.parent(CRV, self.groupNode) #cleanup attribute.lockAndHide(CRV, ['t', 'r', 's', 'v'], False) cmds.setAttr("RIG_GRP.overrideDisplayType", 0) cmds.setAttr(endLoc[0] + ".visibility", 0) return startLoc, endLoc
def CreateAgent(self, number): ##Seting up Names agent_name = 'Agent_' + str(number) ## Setting up random Positions initPos = [] initPos.append(random.random(-self.BoxBoundry[0]/2.0,self.BoxBoundry[0]/2.0) initPos.append(random.random(-self.BoxBoundry[1]/2.0,self.BoxBoundry[1]/2.0) initPos.append(random.random(-self.BoxBoundry[2]/2.0,self.BoxBoundry[2]/2.0) ## Setting up random Velocities initVol = [] initVol.append(random.random(-1.0,1.0)) initVol.append(random.random(-1.0,1.0)) initVol.append(random.random(-1.0,1.0)) ##Creating agent and adding to the list. self.AgentsList.append(Agent(agent_name, initPos, initVol) ## Create Mesh cmds.select( clear=True ) cmds.polyCone(sx=4, n = agent_name) print "Cone Made" cmds.setAttr( agent_name+".rotateY",45.0) cmds.setAttr( agent_name+".rotateZ",90.0) cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0) cmds.setAttr( agent_name+".scaleY" ,0.75) cmds.setAttr( agent_name+".rotateY" ,90.0) cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0) cmds.delete(ch=True) def initPos(self): pass def moveAll(self): for b in self.AgentsList: CheckingNeighbours(b) if self.Rules[0] == True: # Rule 1: Separation Separation(b) else if self.Rules[1] == True: # Rule 2: Alignment Alignment(b) else if self.Rules[2] == True: # Rule 3: Cohesion Cohesion(b) else if self.Rules[3] == True: # Rule 4: LimitSpeed pass else if self.Rules[4] == True: # Rule 5: OutofBounds pass else if self.Rules[5] == True: # Rule 6: Wind pass else if self.Rules[6] == True: # Rule 7: TendTowardsGoal pass else if self.Rules[7] == True: # Rule 8: FleeTargetLocation pass else if self.Rules[8] == True: # Rule 9: ObjectAvoidance pass def CheckingNeighbours(self, aBoid): NeiList = [] for b in self.AgentsList: if aboid != b: if sqrt(pow(aboid.currentPosition[0] - b.currentPositionp[0],2) + pow(aboid.currentPosition[1] - b.currentPositionp[2],2) + pow(aboid.currentPosition[0] - b.currentPositionp[2],2)) <=25: NeiList.append(b) aboid.setNeighbours(NeiList) def Separation(self, aBoid): # Rule 1: Separation Separation = [0.0, 0.0, 0.0] for b in aBoid.neighboursList: if aboid != b: if sqrt(pow(aboid.currentPosition[0] - b.currentPositionp[0],2) + pow(aboid.currentPosition[1] - b.currentPositionp[2],2) + pow(aboid.currentPosition[0] - b.currentPositionp[2],2)) <= self.separationDistance: Separation = [(aboid.currentPosition[0] - b.currentPositionp[0]), return def Alignment(self, aBoid): # Rule 2 pass def Cohesion(self, aBoid): # Rule 3 pass def LimitSpeed(self, aBoid): # Rule 4 pass def OutofBounds(self, aBoid): # Rule 5 #if aboid pos x < top_bound pass def Wind(self, aBoid): #Rule 6 return self.Wind def TendTowardsGoal(self, aBoid): # Rule 7 pass def FleeTargetLocation(self, aBoid, aTarget): # Rule 8 pass def ObjectAvoidance(self, aBoid, aObject): # Rule 9 pass # Sphere, Cylinder and Cube class Agent(object): def __init__(self, Name = 'Agent' , position = [0.0,0.0,0.0], velocity = [1.0,0.0,0.0], viewRadius = 120, ): self.currentVelocity = velocity self.currentPosition = position self.heading = [0.0, 0.0] self.newPosition = self.currentPosition self.viewRadius = viewRadius self.neighboursList = [] def SetPosition(self, coords = [0.0, 0.0, 0.0]): pass def setNeighbours(self, mNeighbours = []): self.neighboursList = mNeighbours
def testAnimSubDDeleteReload(self): # create a subD cube and animate shapeName = 'cube' MayaCmds.polyCube( name=shapeName ) MayaCmds.select('cubeShape') MayaCmds.addAttr(longName='SubDivisionMesh', attributeType='bool', defaultValue=True) MayaCmds.move(5, 0, 0, r=True) MayaCmds.setKeyframe(shapeName+'.vtx[2:5]', time=[1, 24]) MayaCmds.currentTime(12) MayaCmds.select(shapeName+'.vtx[2:5]',replace=True) MayaCmds.move(0, 4, 0, r=True) MayaCmds.setKeyframe(shapeName+'.vtx[2:5]', time=[12]) # create a subD sphere and animate shapeName = 'sphere' MayaCmds.polySphere(name=shapeName) MayaCmds.select('sphereShape') MayaCmds.addAttr(longName='SubDivisionMesh', attributeType='bool', defaultValue=True) MayaCmds.move(-5, 0, 0, r=True) MayaCmds.setKeyframe(shapeName+'.vtx[200:379]', shapeName+'.vtx[381]', time=[1, 24]) MayaCmds.currentTime(12) MayaCmds.select(shapeName+'.vtx[200:379]', shapeName+'.vtx[381]', replace=True) MayaCmds.scale(0.5, 0.5, 0.5, relative=True) MayaCmds.setKeyframe(shapeName+'.vtx[200:379]', shapeName+'.vtx[381]', time=[12]) MayaCmds.currentTime(1) # create a subD torus and animate shapeName = 'torus' MayaCmds.polyTorus(name=shapeName) MayaCmds.select('torusShape') MayaCmds.addAttr(longName='SubDivisionMesh', attributeType='bool', defaultValue=True) MayaCmds.setKeyframe(shapeName+'.vtx[200:219]',time=[1, 24]) MayaCmds.currentTime(12) MayaCmds.select(shapeName+'.vtx[200:219]',replace=True) MayaCmds.scale(2, 1, 2, relative=True) MayaCmds.setKeyframe(shapeName+'.vtx[200:219]', time=[12]) # create a subD cone and animate shapeName = 'cone' MayaCmds.polyCone( name=shapeName ) MayaCmds.select('coneShape') MayaCmds.addAttr(longName='SubDivisionMesh', attributeType='bool', defaultValue=True) MayaCmds.move(0, 0, -5, r=True) MayaCmds.setKeyframe(shapeName+'.vtx[20]', time=[1, 24]) MayaCmds.currentTime(12) MayaCmds.select(shapeName+'.vtx[20]',replace=True) MayaCmds.move(0, 4, 0, r=True) MayaCmds.setKeyframe(shapeName+'.vtx[20]', time=[12]) self.__files.append(util.expandFileName('testSubDReload.abc')) # write it out to Abc file and load back in MayaCmds.AbcExport(j='-fr 1 24 -root cube -root sphere -root torus -root cone -file ' + self.__files[-1]) # load back the Abc file, delete the sphere and save to a maya file MayaCmds.AbcImport( self.__files[-1], mode='open' ) MayaCmds.delete('sphere') self.__files.append(util.expandFileName('test.mb')) MayaCmds.file(rename=self.__files[-1]) MayaCmds.file(save=True) # import the saved maya file to compare with the original scene MayaCmds.file(self.__files[-1], open=True) MayaCmds.select('cube', 'torus', 'cone', replace=True) MayaCmds.group(name='ReloadGrp') MayaCmds.AbcImport(self.__files[-2], mode='import') shapeList = MayaCmds.ls(type='mesh') self.failUnlessEqual(len(shapeList), 7) # test the equality of cubes meshes = [('|cube|cubeShape', '|ReloadGrp|cube|cubeShape'), ('|torus|torusShape', '|ReloadGrp|torus|torusShape'), ('|cone|coneShape', '|ReloadGrp|cone|coneShape')] for m in meshes: for t in range(1, 25): MayaCmds.currentTime(t, update=True) if not util.compareMesh(m[0], m[1]): self.fail('%s and %s are not the same at frame %d' % (m[0], m[1], t))
def cryMakeSceneRoot(naturalOrientation): root_name = 'SceneRoot' if cmds.objExists(root_name): parents = cmds.listRelatives(root_name, p=True) if parents: cmds.confirmDialog( title='CryTools', message= '{0} node has a parent - it is not recommended.\nPlease delete the node {0} or move it to the top of the scene graph.' .format(root_name), button=[ 'Ok', ], defaultButton='Ok') cmds.select(root_name, r=True) return children = cmds.listRelatives(root_name, c=True) if children and sorted(children) != sorted(['forward', 'up']): cmds.confirmDialog( title='CryTools', message= 'A *non-standard* node {0} is found - it is not supported.\nPlease delete the node {0}.' .format(root_name), button=[ 'Ok', ], defaultButton='Ok') cmds.select(root_name, r=True) return cmds.delete(root_name, hi='all') # Creating SceneRoot node cmds.createNode('transform', n=root_name) # Creating geometry of SceneRoot, # including in-scene text labels for the axes. # Note that 'size' is actually a scaler, not a real size size = 1.4 shaft_length = 60.0 * size shaft_radius = 2.0 * size arrowhead_length = 13.0 * size arrowhead_radius = 6.0 * size sphere_radius = 7.0 * size font_size = 40.0 * size font = "Arial|h-" + str(font_size) + "|w400|c0" obj = cmds.createNode('transform') crySetParent(root_name, obj, 'forward') obj = cmds.createNode('transform') crySetParent(root_name, obj, 'up') obj = cmds.polyCylinder(ch=True, o=True, ax=(0, 1, 0), r=shaft_radius, h=shaft_length, sc=1, cuv=3, sx=4) crySetTransform(obj[0], [0.0, shaft_length * 0.5, 0.0], [0.0, 0.0, 0.0]) crySetParent(root_name + '|forward', obj[0], "shaft") obj = cmds.polyCylinder(ch=True, o=True, ax=(0, 0, 1), r=shaft_radius, h=shaft_length, sc=1, cuv=3, sx=4) crySetTransform(obj[0], [0.0, 0.0, shaft_length * 0.5], [0.0, 0.0, 0.0]) crySetParent(root_name + '|up', obj[0], "shaft") obj = cmds.polyCone(ch=True, o=True, ax=(0, 1, 0), r=arrowhead_radius, h=arrowhead_length, cuv=3, sx=6) crySetTransform(obj[0], [0.0, shaft_length + arrowhead_length * 0.5, 0.0], [0.0, 0.0, 0.0]) crySetParent(root_name + '|forward', obj[0], "arrowhead") obj = cmds.polySphere(ch=True, o=True, r=sphere_radius, sx=8, sy=8) crySetTransform(obj[0], [0.0, 0.0, shaft_length + sphere_radius * 0.5], [90.0, 0.0, 0.0]) crySetParent(root_name + '|up', obj[0], "sphere") obj = cmds.textCurves(f=font, t="Forward") crySetTransform(obj[0], [-2.0 * shaft_radius, 0.1 * shaft_length, 0.0], [0.0, 0.0, 90.0]) crySetParent(root_name + '|forward', obj[0], "text") obj = cmds.textCurves(f=font, t="Up") crySetTransform(obj[0], [-2.0 * shaft_radius, 0.0, 0.7 * shaft_length], [0.0, 90.0, 90.0]) crySetParent(root_name + '|up', obj[0], "text") cmds.select(root_name + '|forward', hi=True) cmds.polyColorPerVertex(rgb=(0.0, 0.6, 0.0), a=1, cdo=True) cmds.select(root_name + '|up', hi=True) cmds.polyColorPerVertex(rgb=(0.0, 0.0, 1.0), a=1, cdo=True) # Setting orientation of SceneRoot node if cmds.upAxis(q=True, axis=True) == "z": if naturalOrientation: crySetTransform(root_name, [0, 0, 0], [0, 0, 180.0]) else: crySetTransform(root_name, [0, 0, 0], [0, 0, 0]) else: if naturalOrientation: crySetTransform(root_name, [0, 0, 0], [90.0, 0, 180.0]) else: crySetTransform(root_name, [0, 0, 0], [-90.0, 0, 0]) # Selecting SceneRoot node to let the user see that something happened and/or # to help the user delete/hide/etc. the node. cmds.select(root_name, r=True)
def make_cone(cls): cmds.polyCone()
def testAnimPolyDeleteReload(self): # create a poly cube and animate shapeName = 'pCube' MayaCmds.polyCube( name=shapeName ) MayaCmds.move(5, 0, 0, r=True) MayaCmds.setKeyframe( shapeName+'.vtx[2:5]', time=[1, 24] ) MayaCmds.currentTime( 12 ) MayaCmds.select( shapeName+'.vtx[2:5]',replace=True ) MayaCmds.move(0, 4, 0, r=True) MayaCmds.setKeyframe( shapeName+'.vtx[2:5]', time=[12] ) # create a poly sphere and animate shapeName = 'pSphere' MayaCmds.polySphere( name=shapeName ) MayaCmds.move(-5, 0, 0, r=True) MayaCmds.setKeyframe( shapeName+'.vtx[200:379]', shapeName+'.vtx[381]', time=[1, 24]) MayaCmds.currentTime(12) MayaCmds.select( shapeName+'.vtx[200:379]', shapeName+'.vtx[381]',replace=True) MayaCmds.scale(0.5, 0.5, 0.5, relative=True) MayaCmds.setKeyframe( shapeName+'.vtx[200:379]', shapeName+'.vtx[381]', time=[12]) MayaCmds.currentTime(1) # create a poly torus and animate shapeName = 'pTorus' MayaCmds.polyTorus(name=shapeName) MayaCmds.setKeyframe(shapeName+'.vtx[200:219]',time=[1, 24]) MayaCmds.currentTime(12) MayaCmds.select(shapeName+'.vtx[200:219]',replace=True) MayaCmds.scale(2, 1, 2, relative=True) MayaCmds.setKeyframe(shapeName+'.vtx[200:219]', time=[12]) # create a poly cone and animate shapeName = 'pCone' MayaCmds.polyCone(name=shapeName) MayaCmds.move(0, 0, -5, r=True) MayaCmds.setKeyframe(shapeName+'.vtx[20]', time=[1, 24]) MayaCmds.currentTime(12) MayaCmds.select(shapeName+'.vtx[20]',replace=True) MayaCmds.move(0, 4, 0, r=True) MayaCmds.setKeyframe(shapeName+'.vtx[20]', time=[12]) # write it out to Abc file and load back in self.__files.append(util.expandFileName('testPolyReload.abc')) MayaCmds.AbcExport(j='-fr 1 24 -root pCube -root pSphere -root pTorus -root pCone -file %s' % self.__files[-1]) # load back the Abc file, delete the sphere and save to a maya file MayaCmds.AbcImport( self.__files[-1], mode='open') MayaCmds.delete('pSphere') self.__files.append(util.expandFileName('test.mb')) MayaCmds.file(rename=self.__files[-1]) MayaCmds.file(save=True) # import the saved maya file to compare with the original scene MayaCmds.file(self.__files[-1], open=True) MayaCmds.select('pCube', 'pTorus', 'pCone', replace=True) MayaCmds.group(name='ReloadGrp') MayaCmds.AbcImport(self.__files[-2], mode='import') shapeList = MayaCmds.ls(type='mesh') self.failUnlessEqual(len(shapeList), 7) meshes = [('|pCube|pCubeShape', '|ReloadGrp|pCube|pCubeShape'), ('|pTorus|pTorusShape', '|ReloadGrp|pTorus|pTorusShape'), ('|pCone|pConeShape', '|ReloadGrp|pCone|pConeShape')] for m in meshes: for t in range(1, 25): MayaCmds.currentTime(t, update=True) if not util.compareMesh(m[0], m[1]): self.fail('%s and %s are not the same at frame %d' % (m[0], m[1], t))
# This line of codes are just very basic. beta version i say. # Select the locators and run this code. import maya.cmds as cmds # This will detect the selection order . selection_list = cmds.ls(orderedSelection=True) # then loop one by one selected locators to add the cones in it for obj in selection_list: # Creates a new cone new_cone = cmds.polyCone(r=5, h=20, name='%s_cone' % (obj)) cmds.move(0, 10, 0) cmds.rotate(0, 0, 180) # moved the cone pivot to the tip of the cone ( considering cone is in by default at the origin ) cmds.move(0, -10, 0, ['%s_cone.scalePivot' % (obj), '%s_cone.rotatePivot' % (obj)], relative=True) # constrain the each created cone with the locator by selection order. cmds.pointConstraint(obj, new_cone) # deselct any selected object . cmds.select(clear=True)
def create_cone(*arg, **kwarg): print "create my cone" cmds.polyCone()