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
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#')
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()
