def test_assertConstrained(self):
a = cmds.polySphere()[0]
b = cmds.polySphere()[0]
temp = cmds.parentConstraint(a,b)
self.assertTrue( self.lib.assertConstrained(a, b, type='parent') )
cmds.delete(temp)
temp = cmds.aimConstraint(a,b)
self.assertTrue( self.lib.assertConstrained(a, b, type='aim') )
cmds.delete(temp)
temp = cmds.pointConstraint(a,b)
self.assertTrue( self.lib.assertConstrained(a, b, type='point') )
cmds.delete(temp)
temp = cmds.orientConstraint(a,b)
self.assertTrue( self.lib.assertConstrained(a,b,type='orient') )
cmds.delete(temp)
temp = cmds.scaleConstraint(a,b)
self.assertTrue( self.lib.assertConstrained(a,b,type='scale') )
cmds.delete(temp)
temp = cmds.geometryConstraint(a,b)
self.assertTrue( self.lib.assertConstrained(a,b,type='geometry') )
cmds.delete(temp)
try:
self.lib.assertConstrained(a,b,type='parent')
except AssertionError:
pass
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 HI(self):
if self.checkSphere.isChecked():
cmds.polySphere()
if self.checkTorus.isChecked():
cmds.polyTorus()
if self.checkCube.isChecked():
cmds.polyCube()
pass
def snapToMeshTest():
inMeshT = cmds.polySphere()
inMesh = cmds.listRelatives(inMeshT[0], fullPath = True, shapes = True)
print inMesh
outObj = cmds.polySphere(radius = 0.1)
ctrl = cmds.circle(r=0.5, n="cn_arm_fk_ctrl");
cmds.move(1,0,0,ctrl)
snapToMesh(inMesh = inMesh[0], outObj = outObj[0], ctrlObj=ctrl[0])
def _setup_plugin(self):
collider = cmds.polySphere()[0]
target = cmds.polySphere(subdivisionsAxis=20,
subdivisionsHeight=20)[0]
# target = cmds.polyCube()
plugin = cmds.deformer(target, type=self.name)[0]
cmds.connectAttr('%s.worldInverseMatrix' % collider,
'%s.volumeInverseMatrix' % plugin)
def HI(self):
if self.checkSphere.isChecked():
cmds.polySphere()
if self.checkTorus.isChecked():
cmds.polyTorus()
if self.checkCube.isChecked():
cmds.polyCube()
pass
def createRig(self):
# Create a Cube for test cases
mc.polySphere(name='mySphere')
objCenter = mc.objectCenter('mySphere', l=True)
# Get the bounding box for the selected ojbject
XYZ = mc.xform('mySphere', bb=True, q=True)
rad = XYZ[3] / 2 * self.settings.radius
strltPos = self.settings.lightPos
lightP = 0.0
if strltPos == "High":
lightP = 5.0
elif strltPos == "Low":
lightP = -5.0
else:
lightP = 0.0
# Create a circle to place three point lights
mc.circle(n='curveLights', nr=(0, 1, 0), c=(0, 0, 0), sections=9, radius=rad)
# Create lights in three positions on the curve
loc = mc.pointOnCurve('curveLights', pr=0.0, p=True)
#_item = mc.spotLight(name='FillLight', coneAngle=45)
_item = self.createLight(self.fillLight, "FillLight")
mc.move(loc[0], loc[1]+lightP, loc[2], _item, ls=True)
loc = mc.pointOnCurve('curveLights', pr=3.0, p=True)
#_item = mc.spotLight(name='KeyLight', coneAngle=45)
_item = self.createLight(self.keyLight, "KeyLight")
mc.move(loc[0], loc[1]+lightP, loc[2], _item, ls=True)
loc = mc.pointOnCurve('curveLights', pr=6.0, p=True)
#_item = mc.spotLight(name='RimLight', coneAngle=45)
_item = self.createLight(self.rimLight, "RimLight")
mc.move(loc[0], loc[1]+lightP, loc[2], _item, ls=True)
# Create space locator and aimConstraints
mc.spaceLocator(n='fillLocator', p=(objCenter[0], objCenter[1], objCenter[2]))
mc.aimConstraint('fillLocator', 'FillLight', aimVector=(0.0, 0.0, -1.0))
mc.parent('fillLocator', 'curveLights', relative=True)
mc.spaceLocator(n='keyLocator', p=(objCenter[0], objCenter[1], objCenter[2]))
mc.aimConstraint('keyLocator', 'KeyLight', aimVector=(0.0, 0.0, -1.0))
mc.parent('keyLocator', 'curveLights', relative=True)
mc.spaceLocator(n='rimLocator', p=(objCenter[0], objCenter[1], objCenter[2]))
mc.aimConstraint('rimLocator', 'RimLight', aimVector=(0.0, 0.0, -1.0))
mc.parent('rimLocator', 'curveLights', relative=True)
# Create lights main locator
mc.spaceLocator(n='lightsMainLocator', p=(objCenter[0], objCenter[1], objCenter[2]))
mc.parent('FillLight', 'lightsMainLocator', relative=True)
mc.parent('KeyLight', 'lightsMainLocator', relative=True)
mc.parent('RimLight', 'lightsMainLocator', relative=True)
# Create Main Group for the entire light rig
mc.group('curveLights', 'lightsMainLocator', n='LightRigGroup')
def diamondLattice(dimX=1, dimY=1, dimZ=1, radiusBall = 0.1, radiusStick = 0.02, latticeConst = 1.0, sticks = True):
for x in xrange (0, dimX + 1):
for y in xrange (0, dimY + 1):
for z in xrange (0, dimZ + 1):
scBalls(x, y, z, radiusBall, latticeConst)
#coordinates for translation of spheres to lattice points
xCoord = x * latticeConst
yCoord = y * latticeConst
zCoord = z * latticeConst
xCoordFace = (x + 0.5) * latticeConst
yCoordFace = (y + 0.5) * latticeConst
zCoordFace = (z + 0.5) * latticeConst
xCoordDia25 = (x + 0.25) * latticeConst
yCoordDia25 = (y + 0.25) * latticeConst
zCoordDia25 = (z + 0.25) * latticeConst
xCoordDia75 = (x + 0.75) * latticeConst
yCoordDia75 = (y + 0.75) * latticeConst
zCoordDia75 = (z + 0.75) * latticeConst
faceTranslations = [(xCoordFace, yCoordFace, zCoord), (xCoord, yCoordFace, zCoordFace), (xCoordFace, yCoord, zCoordFace)]
nameSuffix = str(x) + str(y) + str(z)
suffixDimChar = ['x', 'y', 'z']
#fcc atoms
for i in xrange(0, 3):
if suffixDimChar[i] == 'x' and x != dimX and y!= dimY or suffixDimChar[i] == 'y' and z != dimZ and y != dimY or suffixDimChar[i] == 'z' and x != dimX and z!=dimZ:
#facecentered balls
nameFaceBall = 'faceBall' + suffixDimChar[i] + nameSuffix
cmds.polySphere(sx=10, sy=10, r=radiusBall, n=nameFaceBall)
cmds.setAttr(str(nameFaceBall)+'.translate', faceTranslations[i][0], faceTranslations[i][1], faceTranslations[i][2])
diamondTranslations = [(xCoordDia25, yCoordDia25, zCoordDia25), (xCoordDia75, yCoordDia75, zCoordDia25), (xCoordDia25, yCoordDia75, zCoordDia75), (xCoordDia75, yCoordDia25, zCoordDia75)]
for i in xrange(0, 4):
if x != dimX and y != dimY and z != dimZ:
# 1/4 balls
nameDiaBall = 'diaBall' + str(i) + nameSuffix
cmds.polySphere(sx=10, sy=10, r=radiusBall, n=nameDiaBall)
cmds.setAttr(str(nameDiaBall)+'.translate', diamondTranslations[i][0], diamondTranslations[i][1], diamondTranslations[i][2])
# bonds between lattice points
if sticks == True:
axes = [(-1, -1, -1), (1, 1, -1), (-1, 1, 1), (1, -1, 1)]
heightDia = math.sqrt(3) * 0.25 * latticeConst
for j in xrange(0, 4):
#diamond sticks
nameDiaStick = 'diaStick' + str(i) + str(j) + '_' + nameSuffix
cmds.polyCylinder(r=radiusStick, h=heightDia, sx=5, n=nameDiaStick, axis=axes[i])
cmds.setAttr(str(nameDiaStick)+'.translate', diamondTranslations[j][0] + 0.125*axes[i][0], diamondTranslations[j][1] + 0.125*axes[i][1], diamondTranslations[j][2] + 0.125*axes[i][2])
def prepareBaseMesh():
''' Initialize the base mesh with the proper Paintable Attribute on its Shape Node, as well as generate the Control Sphere and vertex graph. '''
if mc.attributeQuery('growthWeights', node=baseMeshShape,
exists=True) == False:
mc.addAttr(baseMeshShape,
ln='growthWeights',
nn='GrowthWeights',
dt='doubleArray')
mc.makePaintable('mesh', 'growthWeights', at='doubleArray')
# Create the control sphere and assign it a semi-transparent material
if mc.objExists(controlSphereName) == False:
mc.polySphere(n=controlSphereName, r=1)
semitransparentMaterial = mc.shadingNode('blinn', asShader=True)
mc.setAttr(semitransparentMaterial + '.transparency',
0.3,
0.3,
0.3,
type='double3')
mc.select(controlSphereName)
mc.hyperShade(a=semitransparentMaterial)
mSel = om.MSelectionList()
mSel.add(baseMeshName)
om.MGlobal.getActiveSelectionList(mSel)
dagPath = om.MDagPath()
component = om.MObject()
mSel.getDagPath(0, dagPath, component)
# Get positions of all vertices on the mesh
meshFn = om.MFnMesh(dagPath)
positions = om.MPointArray()
meshFn.getPoints(positions, om.MSpace.kWorld)
# Iterate and calculate vectors based on connected vertices
iter = om.MItMeshVertex(dagPath, component)
connectedVertices = om.MIntArray()
checkedNodes = [False] * positions.length()
# Initialize the graph with the base mesh's vertices
while not iter.isDone():
curVertexID = iter.index()
checkedNodes[curVertexID] = True
g.addVertex(curVertexID)
iter.getConnectedVertices(connectedVertices)
for i in range(connectedVertices.length()):
neighbourID = connectedVertices[i]
if checkedNodes[neighbourID] == False:
g.addVertex(neighbourID)
g.addEdge(
curVertexID, neighbourID,
squareDistance(positions[curVertexID],
positions[neighbourID]))
iter.next()
def scBalls(x, y, z, radiusBall, latticeConst):
xCoord = x * latticeConst
yCoord = y * latticeConst
zCoord = z * latticeConst
nameSuffix = str(x) + str(y) + str(z)
nameBall = 'ball' + nameSuffix
cmds.polySphere(sx=10, sy=10, r=radiusBall, n=nameBall)
cmds.setAttr(str(nameBall) + '.translate', xCoord, yCoord, zCoord)
def scBalls(x, y, z, radiusBall, latticeConst):
xCoord = x*latticeConst
yCoord = y*latticeConst
zCoord = z*latticeConst
nameSuffix = str(x) + str(y) + str(z)
nameBall = 'ball' + nameSuffix
cmds.polySphere(sx=10, sy=10, r=radiusBall, n=nameBall)
cmds.setAttr(str(nameBall)+'.translate', xCoord, yCoord, zCoord)
def create_nhair_test_scene():
cmds.file(new=True, force=True)
curves = []
for points in curve_datas:
curves.append(cmds.curve(p=points))
cmds.polySphere()
cmds.select(curves, add=True)
mel.eval('makeCurvesDynamic 2 { "1", "1", "1", "1", "0"};')
def QC_FunctionalTest1():
# Resets everything
QC_TestResetScene()
QC_TestResetHypershade()
# Creates a sphere
cmds.polySphere(n='Object001')
cmds.select('Object001')
# Runs the script
QC_QuickChecker()
def testBasicObjectSetMain():
failures = 0
# Test #1
#
# - Create a sphere and a cube.
# - Create a custom MPxObjectSet and add the sphere and cube to the set.
# - Delete the sphere.
# - Ensure the set is still present.
# - Delete the cube.
# - Ensure the set is deleted.
#
cmds.file(f=True, new=True)
sphere = cmds.polySphere(r=1, sx=20, sy=20, ax=(0, 1, 0), tx=1, ch=1)
cube = cmds.polyCube(w=1, h=1, d=1, sx=1, sy=1, sz=1, ax=(0, 1, 0), tx=1, ch=1)
cmds.select(sphere[0], cube[0])
objSet = maya.mel.eval("spBasicObjectSetTest")
cmds.delete(sphere[0])
if not cmds.objExists(objSet):
failures += 1
cmds.delete(cube[0])
if cmds.objExists(objSet):
failures += 1
if failures > 0:
print "testBasicObjectSetMain (Test #1): FAILED\n"
failures = 0
# Test #2
#
# - Create a sphere and a cube.
# - Create a custom MPxObjectSet and add the sphere to the set.
# - Connect the cube.message -> set.usedBy.
# - Delete the sphere.
# - Ensure the set is still present.
#
cmds.file(f=True, new=True)
sphere = cmds.polySphere(r=1, sx=20, sy=20, ax=(0, 1, 0), tx=1, ch=1)
cube = cmds.polyCube(w=1, h=1, d=1, sx=1, sy=1, sz=1, ax=(0, 1, 0), tx=1, ch=1)
cmds.select(sphere[0])
objSet = maya.mel.eval("spBasicObjectSetTest")
cmds.connectAttr("%s.message" % cube[0], "%s.usedBy[0]" % objSet)
cmds.delete(sphere[0])
if not cmds.objExists(objSet):
failures += 1
if failures > 0:
print "testBasicObjectSetMain (Test #1): FAILED\n"
# Clamp failures to 1.
#
if failures > 1:
failures = 1
return failures
def doIt(self,argList):
cmds.polyPlane(n='myPlane', h=5, w=2)
cmds.polySphere(n='mySphere', r=5)
cmds.select('mySphere')
cmds.move(0,5,0)
cmds.rigidBody( n='myRigidBody', active=True, b=0.5, sf=0.4 )
cmds.select(cl=True)
cmds.gravity(n='myGravity')
cmds.connectDynamic('mySphere', fields='myGravity')
def createBoudingSphere(object):
bbox = cmds.xform(object, bb=True, q=True)
centerPosition = [(bbox[0] + bbox[3]) / 2, (bbox[1] + bbox[4]) / 2,
(bbox[2] + bbox[5]) / 2]
size = max(bbox[3] - bbox[0], bbox[4] - bbox[1], bbox[5] - bbox[2])
sphereName = object + '_bSphere'
cmds.polySphere(n=sphereName, r=size / 2)
cmds.xform(sphereName, translation=centerPosition, ws=True)
def MyGeo(geo):
if geo == "cube":
cmds.polyCube(w=10, h=3, d=3, sx=10, sy=2, sz=2, ch=1)
elif geo == "sphere":
cmds.polySphere(r=1, sx=20, sy=20, ch=1)
elif geo == "torus":
cmds.polyTorus(r=1, sr=0.5, tw=0, sx=20, sy=20, ch=1)
def makeSpheres(*args):
global sphereCountField
global sphereRadiusField
numSpheres = cmds.intField(sphereCountField, query=True, value=True)
myRadius = cmds.floatField(sphereRadiusField, query=True, value=True)
for i in range(numSpheres):
cmds.polySphere(radius=myRadius)
cmds.move((i * myRadius * 2.2), 0, 0)
def RandomSphere():
cmds.polySphere(r=random.randrange(1, 50), sx=4, sy=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 RandomSphere():
cmds.polySphere(r = random.randrange(1,50), sx=4, sy=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 createObj():
Opt = cmds.optionMenu('Object', query=True, select=True)
if Opt == 1:
cmds.polyCube()
else:
pass
if Opt == 2:
cmds.polySphere()
else:
pass
def bccLattice(dimX=1,
dimY=1,
dimZ=1,
radiusBall=0.1,
radiusStick=0.02,
latticeConst=1.0,
sticks=True):
for x in xrange(0, dimX + 1):
for y in xrange(0, dimY + 1):
for z in xrange(0, dimZ + 1):
xCoord = x * latticeConst
yCoord = y * latticeConst
zCoord = z * latticeConst
nameSuffix = str(x) + str(y) + str(z)
#scPart of bccLattice
scBalls(x, y, z, radiusBall, latticeConst)
if sticks == True:
scSticks(x, y, z, dimX, dimY, dimZ, radiusStick,
latticeConst)
# ball in body
if x != dimX and y != dimY and z != dimZ:
xCoordBody = xCoord + 0.5 * latticeConst
yCoordBody = yCoord + 0.5 * latticeConst
zCoordBody = zCoord + 0.5 * latticeConst
nameBallBody = 'ballBody' + nameSuffix
cmds.polySphere(sx=10, sy=10, r=radiusBall, n=nameBallBody)
cmds.setAttr(
str(nameBallBody) + '.translate', xCoordBody,
yCoordBody, zCoordBody)
#sticks in body
if sticks == True:
heightBC = latticeConst * math.sqrt(3)
axes = [(1, 1, 1), (1, 1, -1), (1, -1, -1),
(-1, 1, -1)]
for i in xrange(0, 4):
nameStickBody = 'stickBody' + nameSuffix + '_' + str(
i)
cmds.polyCylinder(r=radiusStick,
h=heightBC,
sx=5,
n=nameStickBody,
axis=axes[i])
cmds.setAttr(
str(nameStickBody) + '.translate', xCoordBody,
yCoordBody, zCoordBody)
def lgtSpheresCreator():
#check render engine
renderEngine = mc.getAttr("defaultRenderGlobals.ren")
#create locator
loc = mc.spaceLocator(n="Lgt_Spheres_" + str(renderEngine), p=(0, 0, 0))
#create chromn ball
chromnBallName = mc.polySphere(n=loc[0] + "_chromnBall")
mc.delete(chromnBallName, ch=True)
chromnBallShape = mc.listRelatives(chromnBallName[0], s=True)
mc.setAttr(chromnBallShape[0] + '.castsShadows', 0)
mc.setAttr(chromnBallShape[0] + '.receiveShadows', 0)
mc.setAttr(chromnBallShape[0] + '.visibleInReflections', 0)
mc.setAttr(chromnBallShape[0] + '.visibleInRefractions', 0)
mc.setAttr(chromnBallName[0] + '.translateY', 7)
mc.parent(chromnBallName[0], loc[0], relative=True)
chromnBall = mc.ls(chromnBallName[0], l=True)
#create gray ball
grayBallName = mc.polySphere(n=loc[0] + "_grayBall")
mc.delete(grayBallName, ch=True)
grayBallShape = mc.listRelatives(grayBallName[0], s=True)
mc.setAttr(grayBallShape[0] + '.castsShadows', 0)
mc.setAttr(grayBallShape[0] + '.receiveShadows', 0)
mc.setAttr(grayBallShape[0] + '.visibleInReflections', 0)
mc.setAttr(grayBallShape[0] + '.visibleInRefractions', 0)
mc.setAttr(grayBallName[0] + '.translateY', 4.5)
mc.parent(grayBallName[0], loc[0], relative=True)
grayBall = mc.ls(grayBallName[0], l=True)
#create white ball
whiteBallName = mc.polySphere(n=loc[0] + "_whiteBall")
mc.delete(whiteBallName, ch=True)
whiteBallShape = mc.listRelatives(whiteBallName[0], s=True)
mc.setAttr(whiteBallShape[0] + '.castsShadows', 0)
mc.setAttr(whiteBallShape[0] + '.receiveShadows', 0)
mc.setAttr(whiteBallShape[0] + '.visibleInReflections', 0)
mc.setAttr(whiteBallShape[0] + '.visibleInRefractions', 0)
mc.setAttr(whiteBallName[0] + '.translateY', 2)
mc.parent(whiteBallName[0], loc[0], relative=True)
whiteBall = mc.ls(whiteBallName[0], l=True)
#create and assign shaders by render engine
if renderEngine == "vray":
assignVrayShaders(chromnBall, grayBall, whiteBall)
mc.select(loc, r=True)
elif renderEngine == "arnold":
assignArnoldShaders(chromnBall, grayBall, whiteBall)
mc.select(loc, r=True)
else:
assignMayaShaders(chromnBall, grayBall, whiteBall)
mc.select(loc, r=True)
def testSet_noNormals_Attr(self):
MayaCmds.polyCube(name='polyCube')
# add the necessary props
MayaCmds.select('polyCubeShape')
MayaCmds.addAttr(longName='SubDivisionMesh',
attributeType='bool',
defaultValue=False)
MayaCmds.addAttr(longName='interpolateBoundary',
attributeType='bool',
defaultValue=True)
MayaCmds.addAttr(longName='noNormals',
attributeType='bool',
defaultValue=False)
MayaCmds.addAttr(longName='flipNormals',
attributeType='bool',
defaultValue=False)
MayaCmds.addAttr(longName='faceVaryingInterpolateBoundary',
attributeType='bool',
defaultValue=False)
MayaCmds.polySphere(name='polySphere')
# add the necessary props
MayaCmds.select('polySphereShape')
MayaCmds.addAttr(longName='SubDivisionMesh',
attributeType='bool',
defaultValue=False)
MayaCmds.addAttr(longName='interpolateBoundary',
attributeType='bool',
defaultValue=True)
MayaCmds.addAttr(longName='noNormals',
attributeType='bool',
defaultValue=True)
MayaCmds.addAttr(longName='flipNormals',
attributeType='bool',
defaultValue=False)
MayaCmds.addAttr(longName='faceVaryingInterpolateBoundary',
attributeType='bool',
defaultValue=False)
#ignore facevaryingType, subdPaintLev
MayaCmds.group('polyCube', 'polySphere', name='polygons')
self.__files.append(
util.expandFileName('staticPoly_noNormals_AttrTest.abc'))
MayaCmds.AbcExport(j='-root polygons -f ' + self.__files[-1])
# reading test
MayaCmds.AbcImport(self.__files[-1], mode='open', debug=False)
# make sure the noNormal attribute is set correctly when the file is loaded
self.failIf(MayaCmds.listAttr('polyCubeShape').count('noNormals') != 0)
self.failUnless(MayaCmds.getAttr('polySphereShape.noNormals'))
def createStaticSolarSystem():
MayaCmds.file(new=True, force=True)
moon = MayaCmds.polySphere(radius=0.5, name="moon")[0]
MayaCmds.move(-5, 0.0, 0.0, r=1)
earth = MayaCmds.polySphere(radius=2, name="earth")[0]
MayaCmds.select(moon, earth)
MayaCmds.group(name="group1")
MayaCmds.polySphere(radius=5, name="sun")[0]
MayaCmds.move(25, 0.0, 0.0, r=1)
MayaCmds.group(name="group2")
def createStaticSolarSystem():
MayaCmds.file(new=True, force=True)
moon = MayaCmds.polySphere(radius=0.5, name="moon")[0]
MayaCmds.move(-5, 0.0, 0.0, r=1)
earth = MayaCmds.polySphere(radius=2, name="earth")[0]
MayaCmds.select(moon, earth)
MayaCmds.group(name='group1')
MayaCmds.polySphere(radius=5, name="sun")[0]
MayaCmds.move(25, 0.0, 0.0, r=1)
MayaCmds.group(name='group2')
def lgtSpheresCreator():
#check render engine
renderEngine = mc.getAttr("defaultRenderGlobals.ren")
#create locator
loc = mc.spaceLocator(n = "Lgt_Spheres_"+str(renderEngine), p = (0,0,0))
#create chromn ball
chromnBallName = mc.polySphere(n = loc[0]+"_chromnBall")
mc.delete(chromnBallName,ch = True)
chromnBallShape = mc.listRelatives(chromnBallName[0], s = True)
mc.setAttr(chromnBallShape[0]+'.castsShadows', 0)
mc.setAttr(chromnBallShape[0]+'.receiveShadows', 0)
mc.setAttr(chromnBallShape[0]+'.visibleInReflections', 0)
mc.setAttr(chromnBallShape[0]+'.visibleInRefractions', 0)
mc.setAttr(chromnBallName[0]+'.translateY', 7)
mc.parent(chromnBallName[0], loc[0], relative = True)
chromnBall = mc.ls(chromnBallName[0], l = True)
#create gray ball
grayBallName = mc.polySphere(n = loc[0]+"_grayBall")
mc.delete(grayBallName,ch = True)
grayBallShape = mc.listRelatives(grayBallName[0], s = True)
mc.setAttr(grayBallShape[0]+'.castsShadows', 0)
mc.setAttr(grayBallShape[0]+'.receiveShadows', 0)
mc.setAttr(grayBallShape[0]+'.visibleInReflections', 0)
mc.setAttr(grayBallShape[0]+'.visibleInRefractions', 0)
mc.setAttr(grayBallName[0]+'.translateY', 4.5)
mc.parent(grayBallName[0], loc[0], relative = True)
grayBall = mc.ls(grayBallName[0], l = True)
#create white ball
whiteBallName = mc.polySphere(n = loc[0]+"_whiteBall")
mc.delete(whiteBallName,ch = True)
whiteBallShape = mc.listRelatives(whiteBallName[0], s = True)
mc.setAttr(whiteBallShape[0]+'.castsShadows', 0)
mc.setAttr(whiteBallShape[0]+'.receiveShadows', 0)
mc.setAttr(whiteBallShape[0]+'.visibleInReflections', 0)
mc.setAttr(whiteBallShape[0]+'.visibleInRefractions', 0)
mc.setAttr(whiteBallName[0]+'.translateY', 2)
mc.parent(whiteBallName[0], loc[0], relative = True)
whiteBall = mc.ls(whiteBallName[0], l = True)
#create and assign shaders by render engine
if renderEngine == "vray":
assignVrayShaders(chromnBall,grayBall,whiteBall)
mc.select(loc, r=True)
elif renderEngine == "arnold":
assignArnoldShaders(chromnBall,grayBall,whiteBall)
mc.select(loc, r=True)
else:
assignMayaShaders(chromnBall,grayBall,whiteBall)
mc.select(loc, r=True)
def initializeBalloon(initRadius):
mc.polySphere(sx = 12, sy = 8, n = "balloonTemp", r = initRadius)
mc.rename( "polySphere1", "balloonTempHistory")
mc.polySoftEdge( a = 180 )
mc.lattice( n = 'balloon', cp = True, dv = (2, 4, 2), objectCentered = True, ldv = (2, 3, 2), outsideLattice = True )
mc.hide()
mc.select('balloonTemp.vtx[84]', r=True)
mc.ChamferVertex()
mc.rename( "polyChamfer1", "tempChamfer" )
mc.setAttr( 'tempChamfer.width', .1 )
mc.delete( 'balloonTemp.f[72]' )
return
def create_and_apply_materials(mdl_from_list):
cmds.polySphere(sx=20, sy=30, r=0.5, name='sphere')
mesh = cmds.ls(orderedSelection=True)
mat = cmds.shadingNode(mdl_from_list,
name='test_%s' % mdl_from_list,
asShader=True)
matSG = cmds.sets(name='%sSG' % mat,
empty=True,
renderable=True,
noSurfaceShader=True)
cmds.connectAttr('%s.outColor' % mat, '%s.surfaceShader' % matSG)
cmds.sets(mesh, e=True, forceElement=matSG)
def setUp(self):
''' Called initially to set up the Maya test environment '''
# Load plugins
self.assertTrue(self.pluginsLoaded)
# Open top_layer.ma scene in testSamples
mayaUtils.openTopLayerScene()
# Create some extra Maya nodes
cmds.polySphere()
# Clear selection to start off
cmds.select(clear=True)
def testSimplePrimWriter(self):
mayaUsdLib.PrimWriter.Register(primWriterTest, "mesh")
cmds.polySphere(r = 3.5, name='apple')
usdFilePath = os.path.join(self.temp_dir,'testPrimWriterExport.usda')
cmds.usdExport(mergeTransformAndShape=True,
file=usdFilePath,
shadingMode='none')
self.assertTrue(primWriterTest.InitCalled)
self.assertTrue(primWriterTest.WriteCalled)
self.assertTrue(primWriterTest.PostExportCalled)
def testScene(prototype="shaderFX"):
"""
Creates a boring default scene with a sphere
Args:
prototype (str): either with "shaderFX" or "prototypeC"
"""
mnpr_system.check()
# create and place test sphere
cmds.polySphere()
testSphere = cmds.ls(sl=True)
mnpr_matPresets.createMaterial(testSphere, prototype=prototype)
mnpr_matPresets.defaultLighting()
lib.printInfo("Default scene created")
def createCore(self):
''' This method creates the core for flower. '''
mc.polySphere(ax=(0, 1, 0))
self.currentCore = mc.ls(sl=True)
mc.scale(1, 0.5, 1)
mc.move(0, 0.2, 0)
# delete history
maya.mel.eval("DeleteHistory")
mc.select(clear=True)
return self.currentCore
def Fond(Stre, Freq, Ampl, colors={222, 202, 163}):
cmds.file(f=True, new=True)
# Stre=cmds.floatSliderGrp(field_strenth,q=True,v=True)
# Freq=cmds.floatSliderGrp(field_frequency,q=True,v=True)
# Ampl=cmds.floatSliderGrp(field_amplitude,q=True,v=True)
#---------Creation Objet--------#
cmds.polyCube(w=20, d=20, h=8, sx=80, sz=80, name="roche") #20 20 / 50
cmds.polySphere(r=10, sa=60, sy=60, name="contenant") #8 / 12
cmds.move(0, 6.5, 0, "contenant")
cmds.polyBoolOp('contenant', 'roche', op=3, n='fond')
cmds.delete(ch=True)
cmds.move(0, -4, 0, "fond")
#---------Selection Face--------#
for i in range(0, 1707):
cmds.select("fond.f[" + str(i) + "]", add=True)
sl = cmds.ls(sl=True)
#---------Texture Deformer--------#
td = cmds.textureDeformer(s=Stre, ps="World", name="Textu".format(sl))
n = cmds.shadingNode("noise".format(sl), asTexture=True)
#--------Attributre Noise-------#
cmds.setAttr("noise1.threshold", 0.014)
cmds.setAttr("noise1.amplitude", Ampl)
cmds.setAttr("noise1.ratio", 0.15)
cmds.setAttr("noise1.frequency", Freq)
cmds.setAttr("noise1.falloff", 1)
cmds.connectAttr(n + ".outColor", td[0] + ".texture", force=True)
Color = cmds.shadingNode('aiStandardSurface', name="colo", asShader=True)
cmds.setAttr("colo.specular", 0)
cmds.setAttr(Color + ".baseColor", colors[0], colors[1], colors[2])
cmds.select("fond", hi=True, add=True)
cmds.hyperShade(assign=Color)
#cmds.window()
#cmds.columnLayout()
#sliderStrenght=cmds.floatSliderGrp(field=True,label="Strenth",minValue=0,maxValue=3,value=1.5,w=400)
#sliderFreq=cmds.floatSliderGrp(field=True,label="Frequency",minValue=0,maxValue=1,value=0.3,w=400)
#sliderAmplitude=cmds.floatSliderGrp(field=True,label="Amplitude",minValue=0,maxValue=1,value=0.4,w=400)
#cmds.button(label="Fond", c="Fond()")
#cmds.showWindow()
def createCore(self):
''' This method creates the core for flower. '''
mc.polySphere( ax=(0, 1, 0) )
self.currentCore = mc.ls( sl=True )
mc.scale( 1, 0.5, 1 )
mc.move( 0, 0.2, 0 )
# delete history
maya.mel.eval( "DeleteHistory" )
mc.select( clear=True )
return self.currentCore
def userSphere(*args):
rs = cmds.intSliderGrp(radiussphere, q=True, v=True)
#Move
yms = cmds.intSliderGrp(ymovesphere, q=True, v=True)
xms = cmds.intSliderGrp(xmovesphere, q=True, v=True)
zms = cmds.intSliderGrp(zmovesphere, q=True, v=True)
#Rotate
yrs = cmds.intSliderGrp(yrotatesphere, q=True, v=True)
xrs = cmds.intSliderGrp(xrotatesphere, q=True, v=True)
zrs = cmds.intSliderGrp(zrotatesphere, q=True, v=True)
#Application
cmds.polySphere(r=rs)
cmds.move(y=yms, x=xms, z=zms)
cmds.rotate(y=yrs, x=xrs, z=zrs)
def testExportJobContextConflicts(self):
"""Testing that merging incompatible contexts generates errors"""
mark = Tf.Error.Mark()
mark.SetMark()
self.assertTrue(mark.IsClean())
cmds.polySphere(r=1)
usdFilePath = os.path.abspath('UsdExportSchemaApiTestBasic.usda')
cmds.mayaUSDExport(mergeTransformAndShape=True,
file=usdFilePath,
jobContext=["Larry", "Curly", "Moe"])
self.assertFalse(mark.IsClean())
errors = mark.GetErrors()
messages = set()
for e in errors:
messages.add(e.commentary)
expected = set([
"Arguments for job context 'Larry' can not include extra contexts.",
"Context 'Curly' and context 'Larry' do not agree on type of argument 'apiSchema'.",
"Context 'Moe' and context 'Larry' do not agree on argument 'geomSidedness'."
])
self.assertEqual(messages, expected)
cmds.file(f=True, new=True)
mark = Tf.Error.Mark()
mark.SetMark()
self.assertTrue(mark.IsClean())
cmds.polySphere(r=1)
usdFilePath = os.path.abspath('UsdExportSchemaApiTestBasic.usda')
cmds.mayaUSDExport(mergeTransformAndShape=True,
file=usdFilePath,
jobContext=["NullAPI", "Moe"])
self.assertFalse(mark.IsClean())
errors = mark.GetErrors()
messages = set()
for e in errors:
messages.add(e.commentary)
expected = set(
["Missing implementation for NullAPIChaser::ExportDefault"])
self.assertEqual(messages, expected)
cmds.file(f=True, new=True)
def createTargetPrim(*args):
#delete existing target primitive
#deleteTargetPrim()
createTargetPrim.targetprim = 0
if UI.targetPrim == 'Cube':
createTargetPrim.targetprim = mc.polyCube(sx=1, sy=1, sz=1)
mc.hyperShade(assign=Materials.shader)
#mc.polyColorPerVertex( rgb=(UI.targetR, UI.targetG, UI.targetB), cdo = True )
#if UI.randomOrientation != False:
#mc.select(targetprim)
mc.rotate(UI.targetOrientation[0],
UI.targetOrientation[1],
UI.targetOrientation[2],
a=True)
if UI.targetMiddle != True:
mc.move(random.randint(-10, 10), random.randint(-10, 10), 35)
else:
mc.move(0, 0, 35)
if UI.targetPrim == 'Sphere':
mc.polySphere(sx=24, sy=24, r=1)
mc.hyperShade(assign=Materials.shader)
#mc.polyColorPerVertex( rgb=(UI.targetR, UI.targetG, UI.targetB), cdo = True )
if UI.targetMiddle != True:
mc.move(random.randint(-10, 10), random.randint(-10, 10), 35)
if UI.targetPrim == 'Cylinder':
mc.polyCylinder(sx=24, sy=2, sz=2)
mc.hyperShade(assign=Materials.shader)
#mc.polyColorPerVertex( rgb=(UI.targetR, UI.targetG, UI.targetB), cdo = True )
if UI.targetMiddle != True:
mc.move(random.randint(-10, 10), random.randint(-10, 10), 35)
if UI.targetPrim == 'Torus':
mc.polyTorus(n='target', sx=24, sy=16, r=2, sr=1)
mc.hyperShade(assign=Materials.shader)
#mc.polyColorPerVertex( rgb=(UI.targetR, UI.targetG, UI.targetB), cdo = True )
if UI.targetMiddle != True:
mc.move(random.randint(-10, 10), random.randint(-10, 10), 35)
if UI.targetPrim == 'Cone':
mc.polyCone(sx=1, sy=1, sz=1)
mc.hyperShade(assign=Materials.shader)
#mc.polyColorPerVertex( rgb=(UI.targetR, UI.targetG, UI.targetB), cdo = True )
if UI.targetMiddle != True:
mc.move(random.randint(-10, 10), random.randint(-10, 10), 35)
def makeClouds():
for i in range(0, 3):
cmds.polySphere(r=20, sx=6, sy=6, n='cloud' + str(i))
cmds.scale(1, 0.2, 0.5, 'cloud' + str(i))
x = random.uniform(10, 100)
y = random.uniform(60, 80)
z = random.uniform(10, 100)
cmds.move(i * x, y, z, 'cloud' + str(i))
for j in range(0, 3):
cmds.duplicate('cloud' + str(i), n='cloud' + str(i) + str(j))
x = random.uniform(10, 100)
y = random.uniform(60, 80)
z = random.uniform(10, 100)
cmds.move(i * x, y, j * z, 'cloud' + str(i) + str(j))
cmds.refresh(f=True)
def QC_FunctionalTest2():
# Resets everything
QC_TestResetScene()
QC_TestResetHypershade()
# Creates two spheres
cmds.polySphere(n='Object001')
cmds.polySphere(n='Object002')
# Moves the spheres
cmds.move(0, 0, 0, 'Object001')
cmds.move(2, 0, 0, 'Object002')
# Selects the spheres
cmds.select('Object001')
cmds.select('Object002', add=True)
# Runs the script
QC_QuickChecker()
def createCollisionSphereGuide(self, name):
shpere = cmds.polySphere(name=n_collisionSphere, sx=6, sy=6)
cmds.polyColorPerVertex(shpere[0], rgb=(0.75,0.75,0))
cmds.polyColorPerVertex(shpere[0], colorDisplayOption=1)
self.setAttr(shpere[0],'overrideEnabled', 1)
self.setAttr(shpere[0],'overrideDisplayType', 2)
return shpere
def createLightStageLight(name, direction, diameterIn, distanceToFrontIn, useGroup=True):
diameterCm = inchesToCentimeters(diameterIn)
distanceToFrontCm = inchesToCentimeters(distanceToFrontIn)
sphereLight = cmds.polySphere(name=name, r=0.5, sx=20, sy=20, ax=[0, 1, 0], cuv=2, ch=1)[0]
lightScale = diameterCm
cmds.setAttr("%s.%s" % (sphereLight, "scaleX"), lightScale)
cmds.setAttr("%s.%s" % (sphereLight, "scaleY"), lightScale)
cmds.setAttr("%s.%s" % (sphereLight, "scaleZ"), lightScale)
if useGroup:
cmds.setAttr("%s.%s" % (sphereLight, "scaleZ"), 0.0)
lightGroup = cmds.group(sphereLight, name=("%sRotation" % sphereLight))
lightTranslate = distanceToFrontCm
cmds.setAttr("%s.%s" % (sphereLight, "translateZ"), lightTranslate)
rx = -math.asin( direction[1] )*180.0/3.14159
ry = math.atan2( direction[0], direction[2] )*180.0/3.14159
cmds.setAttr("%s.%s" % (lightGroup, "rotateX"), rx)
cmds.setAttr("%s.%s" % (lightGroup, "rotateY"), ry)
return lightGroup
else:
lightTranslate = map( lambda x: x*(distanceToFrontCm + diameterCm/2.), direction)
cmds.setAttr("%s.%s" % (sphereLight, "translateX"), lightTranslate[0])
cmds.setAttr("%s.%s" % (sphereLight, "translateY"), lightTranslate[1])
cmds.setAttr("%s.%s" % (sphereLight, "translateZ"), lightTranslate[2])
return sphereLight
def generateCollision(mode="sphere"):
selected = cmds.ls(sl=True)
if not selected:
logging.error("Please Select Something")
return
xmin, ymin, zmin, xmax, ymax, zmax = cmds.xform(selected[0], q=True, bb=True) # give 6 values
width = abs(xmax - xmin)
height = abs(ymax - ymin)
depth = abs(zmax - zmin)
name = selected[0] + "_COL" # new name
if (mode == "box"):
mesh = cmds.polyCube(w=width, h=height, d=depth, n=name)[0]
if (mode == "sphere"):
radius = max([width, height, depth])/2
mesh = cmds.polySphere(r=radius, sx=10, sy=10,n=name)
if (mode == "cylinder"):
radius = max([width,depth])/2
mesh = cmds.polyCylinder(r=radius, h=height, n=name, sc=1, sx=12, sy=1, sz=1)
xPos = xmax - width/2
yPos = ymax - height/2
zPos = zmax - depth/2
cmds.xform(mesh, ws=True, t=[xPos,yPos,zPos])
def setUp(self):
cmds.file(newFile=True, f=True)
self.sphere = cmds.polySphere()
self.loc1 = cmds.spaceLocator()[0]
self.loc2 = cmds.spaceLocator()[0]
self.joint = cmds.joint()
def test_saveAs_export( self ):
tmpdir = make_path( tempfile.gettempdir() ) / "maya_save_test"
try:
shutil.rmtree( tmpdir ) # cleanup
except OSError:
pass
files = [ "mafile.ma" , "mb.mb", "ma.ma" ]
for filename in files:
mayafile = tmpdir / filename
assert not mayafile.exists()
Scene.save( mayafile , force=1 )
assert mayafile.exists()
# END for each file to save
# test remove unknown nodes
assert Scene.name().ext() == ".ma"
target_path = tmpdir / 'withoutunknown.mb'
unode = cmds.createNode("unknown")
# this doesnt work unless we have real unknown data - an unknown node
# itself is not enough
# self.failUnlessRaises(RuntimeError, Scene.save, target_path)
Scene.save(target_path, autodeleteUnknown=True)
assert not cmds.objExists(unode)
# must work for untitled files as well
Scene.new( force = 1 )
Scene.save( tmpdir / files[-1], force = 1 )
# TEST EXPORT
#############
# as long as we have the test dir
# export all
eafile = tmpdir / "export_all.ma"
assert not eafile.exists()
assert Scene.export(eafile) == eafile
assert eafile.exists()
# export selected
nodes = cmds.polySphere()
cmds.select(cl=1) # selects newly created ...
esfile = tmpdir / "export_selected.ma"
assert not esfile.exists()
assert not cmds.ls(sl=1)
assert Scene.export(esfile, nodes) == esfile
assert not cmds.ls(sl=1) # selection unaltered
assert esfile.isfile()
# it truly exported our sphere
Scene.new(force=1)
esref = ref.createReference(esfile)
assert len(list(esref.iterNodes(api.MFn.kMesh))) == 1
shutil.rmtree( tmpdir ) # cleanup
def createControl(lid, tz):
locator1 = mc.spaceLocator(p = (0, 0, 0), n = '%s_locator%d' % (light, lid))[0]
mc.parent(locator1, decay_grp)
locator1 = "|%s|%s" % (decay_grp, locator1)
mc.setAttr("%s.translateX" % locator1, lock = True)
mc.setAttr("%s.translateY" % locator1, lock = True)
mc.setAttr("%s.translateZ" % locator1, tz)
sphere = mc.polySphere(r = 1, sx = 20, sy = 20, ax = (0, 1, 0), cuv = 0, ch = 0, n = '%s_sphere%d' % (light, lid))[0]
mc.parent(sphere, decay_grp)
sphere = "|%s|%s" % (decay_grp, sphere)
# mc.pointConstraint(light, sphere, w = 1)
mc.setAttr("%s.overrideEnabled" % sphere, 1)
mc.setAttr("%s.overrideDisplayType" % sphere, 1)
decomM1 = mc.createNode("decomposeMatrix")
mc.connectAttr("%s.worldMatrix[0]" % light, "%s.inputMatrix" % decomM1, f = True)
decomM2 = mc.createNode("decomposeMatrix")
mc.connectAttr("%s.worldMatrix[0]" % locator1, "%s.inputMatrix" % decomM2, f = True)
dis = mc.createNode("distanceBetween")
mc.connectAttr("%s.outputTranslate" % decomM1, "%s.point1" % dis, f = True)
mc.connectAttr("%s.outputTranslate" % decomM2, "%s.point2" % dis, f = True)
mc.connectAttr("%s.distance" % dis, "%s.scaleX" % sphere, f = True)
mc.connectAttr("%s.distance" % dis, "%s.scaleY" % sphere, f = True)
mc.connectAttr("%s.distance" % dis, "%s.scaleZ" % sphere, f = True)
return dis
def makeTree(shaders):
'''
Creates a tree.
shaders: A list of shaders for the tree crown.
On exit: A tree has been modeled, and is returned as a tuple
containing the object name and the node name. Some of the
variables are chosen randomly to create different results.
'''
height = random.uniform(0.3,1.5)
trunk = cmds.polyCylinder(name = "trunk", h = height, r = 0.07)
cmds.sets(trunk[0], edit=True, forceElement="trunkMaterialGroup")
cmds.xform(trunk, translation = (0,height/2.0 + 0.2,0))
crown = cmds.polySphere(name = "crown", r = 0.5)
cmds.xform(crown, translation = (0,height + 0.6,0))
cmds.softSelect(sse = True, ssd = 0.86)
cmds.select(crown[0] + ".vtx[381]")
translation = random.uniform(0.3,1.5)
cmds.move(translation, y = True, r = True)
cmds.softSelect(sse = False)
shader = random.choice(shaders)
scale_ = random.uniform(0.7,1.8)
cmds.select(crown)
cmds.scale(scale_, scale_, scale_, pivot = (0,height,0))
cmds.sets(crown[0], edit=True, forceElement= shader[1])
tree = cmds.polyUnite(trunk[0],crown[0])
cmds.delete(tree[0], ch = True)
return tree
def on3DSceneClick(self):
if not cmds.window("autorigging_ui", exists=True) :
self.resetExternalContext()
return
if not self.isActive :
self.setConsoleText("Vous devez activer l'autorigging.",color=[255,0,0])
return
if not self.currentPointKey :
self.setConsoleText("Choisissez un type de point a placer.")
return
pos = cmds.draggerContext("riggingContext", query=1, anchorPoint=1)
strPos = "x:"+str(round(pos[0],2)) +"\ny:" + str(round(pos[1],2))
if self.pointsMap[self.currentPointKey]["isSet"] is True :
cmds.delete(self.currentPointKey+"sphere")
nextObj = cmds.polySphere(name=self.currentPointKey+"sphere", radius=0.3)
cmds.move(pos[0], pos[1], 10, nextObj)
cmds.scale(1.0,1.0,0.0, nextObj)
self.pointsMap[self.currentPointKey]["isSet"] = True
self.pointsMap[self.currentPointKey]["clickedPoint"] = pos
cmds.button(self.pointsMap[self.currentPointKey]["stateButton"], e=1, backgroundColor=[0,255,0],label=strPos)
def sphereCtl( name, functArgs ):
J=[]
ctl = Lib.getFirst(cmds.polySphere( n = (name + "_CTL"), r= functArgs["size"], sx= 1, sy= 1, ax= [0, 1, 0], ch= 1))
grp = cmds.group( ctl, n = (name + "Ctl_GRP"))
J.append(ctl)
J.append(grp)
return J
def test_create_constraint():
_new()
cube1, _ = map(cmdx.encode, cmds.polyCube())
sphere1, _ = map(cmdx.encode, cmds.polySphere())
cube1["translate"] = (1, 2, 0)
sphere1["translate"] = (1, 4, 0)
# Use commands, in case the interactive function is failing
scene = commands.create_scene()
commands.create_rigid(cube1, scene)
commands.create_rigid(sphere1, scene)
cmds.select(str(cube1), str(sphere1))
opts = {"constraintSelect": False}
assert_true(interactive.create_point_constraint(**opts))
assert_true(interactive.create_orient_constraint(**opts))
assert_true(interactive.create_parent_constraint(**opts))
assert_true(interactive.create_hinge_constraint(**opts))
assert_true(interactive.create_socket_constraint(**opts))
assert_equals(len(cmds.ls(type="rdRigid")), 2)
assert_equals(len(cmds.ls(type="rdScene")), 1)
assert_equals(len(cmds.ls(type="rdConstraint")), 5)
def setUp(self):
cmds.file(newFile=True,f=True)
self.sphere = cmds.polySphere()
self.loc1 = cmds.spaceLocator()[0]
self.loc2 = cmds.spaceLocator()[0]
self.joint = cmds.joint()
def tf_makeSphere(width, subdivs, parent, child, prefix, suffix ):
dummyBase = '%s' % (parent + child+ '_joint')
dummyName = tf_dummyString(dummyBase, prefix, suffix)
# create the cube
createSphere = cmds.polySphere( r=width, ch=False, sx= 20, sy= 20, n= dummyName )
cmds.editDisplayLayerMembers ( 'DummyLayer', createSphere)
# move cube to parent
pointCon = cmds.pointConstraint( parent, createSphere[0] )
# delete constraint once cube is in position
cmds.delete( pointCon )
# create the aim constraint
#aimCon = cmds.aimConstraint( child, createSphere[0], aim=[0,0,1], u=[0,0,1] )
# delete constraint once cube is aimed at child
#cmds.delete( aimCon )
#parent cube under the parent joint
cmds.parent( createSphere[0], parent )
# freeze transforms
cmds.makeIdentity( createSphere[0], apply=True )
def setUp(self):
"""Export some sphere geometry as .usda, and import into a new Maya scene."""
cmds.file(force=True, new=True)
cmds.loadPlugin("AL_USDMayaPlugin", quiet=True)
self.assertTrue(
cmds.pluginInfo("AL_USDMayaPlugin", query=True, loaded=True))
with tempfile.NamedTemporaryFile(delete=False,
suffix=".usda") as _tmpfile:
self._usdaFile = _tmpfile.name
# Ensure sphere geometry exists
self._sphere = cmds.polySphere(constructionHistory=False,
name="sphere")[0]
cmds.select(self._sphere)
# Export, new scene, import
cmds.file(self._usdaFile,
exportSelected=True,
force=True,
type="AL usdmaya export")
cmds.file(force=True, new=True)
self._proxyName = cmds.AL_usdmaya_ProxyShapeImport(
file=self._usdaFile)[0]
# Ensure proxy exists
self.assertIsNotNone(self._proxyName)
# Store stage
proxy = ProxyShape.getByName(self._proxyName)
self._stage = proxy.getUsdStage()
def four():
#group MODULE
mir = random.randint(0, 19)
crazyR = random.randint(0, 1000)
oven = 'Oven' + str(mir) + str(crazyR)
cmds.group(n=oven, em=True)
base_heigh = cmds.intSliderGrp(slider1, q=True, value=True)
base_width = cmds.intSliderGrp(slider2, q=True, value=True)
base_depth = cmds.intSliderGrp(slider3, q=True, value=True)
#base:
base = cmds.polyCube(h=base_heigh, w=base_width, depth=base_depth)
cmds.polyBevel3(base, offset=0.1)
door = cmds.polyCube(h=base_heigh - base_heigh / 2,
w=base_width - base_width / 2,
depth=0.2)
cmds.move(0, -base_heigh / 20.0, -base_width / 2.0)
cmds.parent(base, door, oven)
#swiches:
sdoor = cmds.ls(door)
for i in range(3):
switch = cmds.polySphere(sx=5, sy=5, r=0.2)
cmds.move(-base_width / 4.0 + i - 0.2 * i, base_heigh / 2.5,
-base_width / 2.1)
cmds.parent(switch, oven)
for i in range(2):
heatersOne = cmds.polyCylinder(sx=7, sy=7, h=0.2, r=base_width / 1000)
cmds.move(-base_width / 6.0 + i, base_heigh / 2.0, -base_width / 3.5)
cmds.parent(heatersOne, oven)
for i in range(2):
heaterTwo = cmds.polyCylinder(sx=7, sy=7, h=0.2, r=base_width / 1000)
cmds.move(-base_width / 6.0 + i, base_heigh / 2.0, base_width / 3.5)
cmds.parent(heaterTwo, oven)
def creatSphere(*args):
circleSel = mc.ls(sl=1)[0]
radiusCircle = mc.circle(circleSel, q=1, r=1)
radiusSpere = radiusCircle*.75
particleSphere = mc.polySphere(n='%s_Sphere'%circleSel, r=radiusSpere, sx=float(radiusSpere), sy=float(radiusSpere), ax=[0, 1, 0])[0]
mc.parentConstraint(circleSel, particleSphere, mo=0, w=1)
#mc.parent(particleSphere, circleSel)
mc.setAttr('%s.tx'%particleSphere, 0)
mc.setAttr('%s.ty'%particleSphere, 0)
mc.setAttr('%s.tz'%particleSphere, 0)
mc.setAttr('%s.rx'%particleSphere, 0)
mc.setAttr('%s.ry'%particleSphere, 0)
mc.setAttr('%s.rz'%particleSphere, 0)
mc.setAttr('%s.v'%particleSphere, 0)
mc.select(particleSphere, r=1)
mc.emitter(type='surface', r=4, dx=1, dy=0, dz=0, n='%s_emitter'%circleSel )
mc.particle( n='%s_Particles'%circleSel )
mc.connectDynamic( '%s_Particles'%circleSel, em='%s_emitter'%circleSel )
particlesShape = mc.listRelatives('%s_Particles'%circleSel, s=1)[0]
mc.setAttr('%s.lifespanMode'%particlesShape, 1)
mc.setAttr('%s.lifespan'%particlesShape, 0.4)
mc.setAttr('%s.startFrame'%particlesShape, 1001)
mc.connectControl( 'numText', '%s.rate'%('%s_emitter'%circleSel) )
mc.shadingNode('blinn', n='%s_blinn'%circleSel, asShader=1)
mc.sets( n='%s_blinnSG'%circleSel, renderable=True, noSurfaceShader=True, empty=1)
mc.connectAttr('%s.outColor'%('%s_blinn'%circleSel), '%s.surfaceShader'%('%s_blinnSG'%circleSel))
mc.connectControl( 'myColorIndex', '%s.color'%('%s_blinn'%circleSel) )
mc.connectControl( 'lifeText', '%s.lifespan'%particlesShape )
mc.sets('%s_Particles'%circleSel, e=1, forceElement='%s'%('%s_blinnSG'%circleSel))
def make_origin_target():
o = cmds.polySphere() # create a sphere
cmds.select(o) # select the sphere
bbox = cmds.exactWorldBoundingBox() # create bounding box around it
bottom = [(bbox[0] + bbox[3])/2, bbox[1], (bbox[2] + bbox[5])/2] # define the bottom of the bounding box
cmds.xform(piv=bottom, ws=True) # move the sphere to the bottom of the bounding box
cmds.move(rpr=True)
cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0) # freeze transforms
def maya_test():
import maya.standalone
maya.standalone.initialize()
from maya import cmds
print 'sphere:', cmds.polySphere()
cmds.file(rename="/home/mboers/key_tools/qbfutures/test.ma")
cmds.file(force=True, save=True, type="mayaAscii")
return 'DONE'
def createSphere(name, startJoint, endJoint):
startHeight = mc.xform(startJoint, q=True, ws=True, t=True)
endHeight = mc.xform(endJoint, q=True, ws=True, t=True)
radius = (endHeight[1]-startHeight[1])/2
tempSphere = mc.polySphere(n=name,r=radius)
tempPos = (startHeight[0], startHeight[1]+radius, startHeight[2])
mc.move(tempPos[0], tempPos[1], tempPos[2], r=True)
return tempSphere[0]
def ballZ( inBitName ):
bit = cmds.polySphere( axis=[0,0,1],
radius=4,
subdivisionsX=8,
subdivisionsY=4,
name=inBitName )
# Return the name of the newly created bit.
return bit[0]
