def npchrome():
### blue clear plastic
global npchromeSG
npchrome = mc.shadingNode('phong', asShader=True, n='npchrome')
npchromeSG = mc.sets(r=True, nss=True, em=True, n='npchromeSG')
mc.connectAttr(npchrome + '.outColor', npchromeSG + '.surfaceShader')
mc.setAttr(npchrome + '.color', 0.0, 0.0, 0.0, type='double3')
mc.setAttr(npchrome + '.transparency', 0.0, 0.0, 0.0, type='double3')
mc.setAttr(npchrome + '.ambientColor', 1.0, 1.0, 1.0, type='double3')
mc.setAttr(npchrome + '.incandescence',
0.122,
0.122,
0.122,
type='double3')
mc.setAttr(npchrome + '.cosinePower', 20)
mc.setAttr(npchrome + '.specularColor', 2.0, 2.0, 2.0, type='double3')
mc.setAttr(npchrome + '.reflectivity', 2.0)
#create water texture and link it
texture = mc.shadingNode('water', at=True, n='chromeTex')
chromePlaceTex = mc.shadingNode('place2dTexture',
au=True,
n='chromePlaceTex')
mc.connectAttr(chromePlaceTex + '.outUV', texture + '.uv')
mc.connectAttr(chromePlaceTex + '.outUvFilterSize',
texture + '.uvFilterSize')
mc.defaultNavigation(ce=True, d=npchrome + '.normalCamera', s=texture)
mc.setAttr(texture + '.alphaIsLuminance', True)
#mc.connectAttr(texture+'.outAlpha', 'bump2d2.bumpValue', f=True )
#mc.connectAttr('bump2d2.outNormal', npchrome+'.bumpValue', f=True )
#set texture settings
mc.setAttr(texture + '.numberOfWaves', 32)
mc.setAttr(texture + '.waveTime', 1.0)
mc.setAttr(texture + '.waveFrequency', 5.25)
def create(self):
#checking if shader exists
shadExist = 0
allShaders = cmds.ls(mat=1)
for shadeCheck in allShaders:
if (shadeCheck == self.name):
shadExist = 1
if (shadExist == 0):
cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name=self.name + "SG")
cmds.shadingNode(self.type, asShader=True, name=self.name)
# 0.0, 0.8, 1.0 color
cmds.setAttr(self.name + ".color",
self.color[0],
self.color[1],
self.color[2],
type='double3')
#transparency between 0.8 - 0.9 is good
cmds.setAttr(self.name + ".transparency",
self.trans[0],
self.trans[1],
self.trans[2],
type="double3")
cmds.setAttr(self.name + ".specularColor",
self.specClr[0],
self.specClr[1],
self.specClr[2],
type='double3')
cmds.connectAttr(self.name + ".outColor",
self.name + "SG.surfaceShader",
f=True)
def _makeMolecule(self):
#H2O
O = cmds.polySphere(r=1, n='O', ax = [0,0,0]);
H1 = cmds.polySphere(r=0.8, n='H1', ax=[0,0,0]);
H2 = cmds.polySphere(r=0.8, n='H2', ax=[0,0,0]);
cmds.move(0.0,0.0,1,H1, r=True)
cmds.move(0.0,0.0,-1,H2, r=True)
cmds.xform(H1, piv=[0,0,0], ws=True)
cmds.xform(H2, piv=[0,0,0], ws=True)
cmds.rotate(0,'60',0, H1);
#group O, H1, H2 as a water molecule
H2O = cmds.group( empty=True, name='H2O' )
cmds.parent(H1,H2,O,H2O)
#paint on colors for the water molecule
#create red lambert
cmds.sets( renderable=True, noSurfaceShader=True, empty=True, name='O_WhiteSG' )
cmds.shadingNode( 'lambert', asShader=True, name='O_White' )
cmds.setAttr( 'O_White.color', 1, 1, 1, type='double3')
cmds.connectAttr('O_White.outColor', 'O_WhiteSG.surfaceShader')
#create red lambert
cmds.sets( renderable=True, noSurfaceShader=True, empty=True, name='H_RedSG' )
cmds.shadingNode( 'lambert', asShader=True, name='H_Red' )
cmds.setAttr( 'H_Red.color', 1, 0, 0, type='double3')
cmds.connectAttr('H_Red.outColor', 'H_RedSG.surfaceShader')
#assign the material
cmds.sets('H1', edit=True, forceElement='H_RedSG')
cmds.sets('H2', edit=True, forceElement='H_RedSG')
cmds.sets('O', edit=True, forceElement='O_WhiteSG')
return H2O
def create(self):
#checking if shader exists
shadExist = 0
allShaders = cmds.ls(mat=1)
for shadeCheck in allShaders:
if (shadeCheck == self.name + '1'):
shadExist = 1
if (shadExist == 0):
cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name=self.name)
cmds.shadingNode('mia_material_x', asShader=True, name=self.name)
self.name = self.name + '1'
cmds.setAttr(self.name + ".diffuse", self.diffuse[0],
self.diffuse[1], self.diffuse[2])
cmds.setAttr(self.name + ".refl_color", self.refl_color[0],
self.refl_color[1], self.refl_color[2])
cmds.setAttr(self.name + ".transparency", self.trans)
cmds.setAttr(self.name + ".refr_color", self.refr_color[0],
self.refr_color[1], self.refr_color[2])
cmds.setAttr(self.name + ".refr_trans_color",
self.refr_trans_color[0], self.refr_trans_color[1],
self.refr_trans_color[2])
cmds.setAttr(self.name + ".refl_gloss", self.refl_gloss)
cmds.setAttr(self.name + ".refr_gloss", self.refr_gloss)
cmds.setAttr(self.name + ".refr_ior", self.refr_ior)
cmds.setAttr(self.name + ".refr_trans_weight",
self.refr_trans_weight)
def assignPlasticShader(name):
selected = cmds.ls(sl=True)[0].encode('ascii', 'ignore')
print(selected)
cmds.sets(name='plasticMaterialGroup', renderable=True, empty=True)
cmds.shadingNode('blinn', name='plasticShader', asShader=True)
cmds.setAttr('plasticShader.color', .667628, 0., 1., type='double3')
cmds.setAttr('plasticShader.diffuse', .5)
cmds.setAttr('plasticShader.eccentricity', .5)
cmds.surfaceShaderList('plasticShader', add='plasticMaterialGroup')
cmds.sets(selected, e=True, forceElement='plasticMaterialGroup')
return name
def createMaterial(name, color, type):
cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name=name + 'SG')
cmds.shadingNode(type, asShader=True, name=name)
cmds.setAttr(name + '.color',
color[0],
color[1],
color[2],
type='double3')
cmds.connectAttr(name + '.outColor', name + 'SG.surfaceShader')
def createShaderFromConfig(cls, shaderConfig):
"""create a shader and engine if not already available"""
if not cls.shaderExistsInScene(shaderConfig):
shader = cmds.shadingNode(
shaderConfig['type'],
name=shaderConfig['uid'],
asShader=True)
cmds.setAttr(shader + '.color', *shaderConfig['color'], type='double3')
if 'transparency' in shaderConfig:
cmds.setAttr(
shader + '.transparency',
*shaderConfig['transparency'], type='double3')
shaderEngine = cmds.sets(
renderable=True,
noSurfaceShader=True,
empty=True,
name=shader + '_SG')
cmds.connectAttr(shader + '.outColor', shaderEngine + '.surfaceShader')
else:
shader = shaderConfig['uid']
engines = cmds.listConnections(shader + '.outColor')
if engines:
shaderEngine = engines[0]
else:
shaderEngine = cmds.sets(
renderable=True,
noSurfaceShader=True,
empty=True,
name=shader + '_SG')
cmds.connectAttr(shader + '.outColor', shaderEngine + '.surfaceShader')
return shader, shaderEngine
def matRedPlastic():
red = cmds.shadingNode('phongE', asShader=True)
cmds.setAttr(red + '.color', 0.77, 0, 0.03, type='double3')
cmds.setAttr(red + '.diffuse', 0.752)
cmds.setAttr(red + '.reflectivity', 0.684)
cmds.setAttr(red + '.reflectedColor', 0.68, 0.47, 0.48, type='double3')
return red
def __init__(self, name, r, g, b):
AA = mc.shadingNode('phong', asShader=True, n=name + '_AA')
self.AASG = mc.sets(r=True, nss=True, em=True, n=name + '_AASG')
mc.connectAttr(AA + '.outColor', self.AASG + '.surfaceShader')
mc.setAttr(AA + '.color', r, g, b, type='double3')
mc.setAttr(AA + '.cosinePower', 2)
mc.setAttr(AA + '.specularColor', r, g, b, type='double3')
mc.setAttr(AA + '.reflectivity', 0.2)
def assignGoldShader(name):
selected = cmds.ls(sl=True)[0].encode('ascii', 'ignore')
print(selected)
cmds.sets(name='goldMaterialGroup', renderable=True, empty=True)
cmds.shadingNode('anisotropic', name='goldShader', asShader=True)
cmds.setAttr('goldShader.color', 1, .775814, 0, type='double3')
cmds.setAttr('goldShader.specularColor', 1, 1, 1, type='double3')
cmds.setAttr('goldShader.diffuse', .475)
cmds.setAttr('goldShader.translucence', .263)
cmds.setAttr('goldShader.translucenceFocus', .869)
cmds.setAttr('goldShader.spreadX', 5)
cmds.setAttr('goldShader.spreadY', 24)
cmds.setAttr('goldShader.roughness', .75)
cmds.setAttr('goldShader.fresnelRefractiveIndex', 9.227)
cmds.surfaceShaderList('goldShader', add='goldMaterialGroup')
cmds.sets(selected, e=True, forceElement='goldMaterialGroup')
return name
def __init__(self, name, r, g, b):
### blue fine metallic
FM = mc.shadingNode('phong', asShader=True, n=name + 'FM')
self.FMSG = mc.sets(r=True, nss=True, em=True, n=name + 'FMSG')
mc.connectAttr(FM + '.outColor', self.FMSG + '.surfaceShader')
mc.setAttr(FM + '.color', r, g, b, type='double3')
mc.setAttr(FM + '.cosinePower', 20)
mc.setAttr(FM + '.specularColor', r, g, b, type='double3')
mc.setAttr(FM + '.reflectivity', 0.8)
def whiteAnodizedAluminum():
### white anodized aluminum
global whiteAASG
whiteAA = mc.shadingNode('phong', asShader=True, n='whiteAA')
whiteAASG = mc.sets(r=True, nss=True, em=True, n='whiteAASG')
mc.connectAttr(whiteAA + '.outColor', whiteAASG + '.surfaceShader')
mc.setAttr(whiteAA + '.color', 0.9, 0.9, 0.9, type='double3')
mc.setAttr(whiteAA + '.cosinePower', 2)
mc.setAttr(whiteAA + '.specularColor', 0.9, 0.9, 0.9, type='double3')
mc.setAttr(whiteAA + '.reflectivity', 0.2)
def blueAnodizedAluminum():
### blue Anodized aluminum
global blueAASG
blueAA = mc.shadingNode('phong', asShader=True, n='blueAA')
blueAASG = mc.sets(r=True, nss=True, em=True, n='blueAASG')
mc.connectAttr(blueAA + '.outColor', blueAASG + '.surfaceShader')
mc.setAttr(blueAA + '.color', 0.0, 0.0, 0.3, type='double3')
mc.setAttr(blueAA + '.cosinePower', 2)
mc.setAttr(blueAA + '.specularColor', 0.0, 0.0, 0.3, type='double3')
mc.setAttr(blueAA + '.reflectivity', 0.2)
def redAnodizedAluminum():
### red anodized aluminum
global redAASG
redAA = mc.shadingNode('phong', asShader=True, n='redAA')
redAASG = mc.sets(r=True, nss=True, em=True, n='redAASG')
mc.connectAttr(redAA + '.outColor', redAASG + '.surfaceShader')
mc.setAttr(redAA + '.color', 0.5, 0.0395, 0.0395, type='double3')
mc.setAttr(redAA + '.cosinePower', 2)
mc.setAttr(redAA + '.specularColor', 0.5, 0.0395, 0.0395, type='double3')
mc.setAttr(redAA + '.reflectivity', 0.2)
def blueFineMetallic():
### blue fine metallic
global blueFMSG
blueFM = mc.shadingNode('phong', asShader=True, n='blueFM')
blueFMSG = mc.sets(r=True, nss=True, em=True, n='blueFMSG')
mc.connectAttr(blueFM + '.outColor', blueFMSG + '.surfaceShader')
mc.setAttr(blueFM + '.color', 0.04, 0.04, 0.5, type='double3')
mc.setAttr(blueFM + '.cosinePower', 20)
mc.setAttr(blueFM + '.specularColor', 0.04, 0.04, 0.5, type='double3')
mc.setAttr(blueFM + '.reflectivity', 0.8)
def redFineMettalic():
### red fine metallic
global redFMSG
redFM = mc.shadingNode('phong', asShader=True, n='redFM')
redFMSG = mc.sets(r=True, nss=True, em=True, n='redFMSG')
mc.connectAttr(redFM + '.outColor', redFMSG + '.surfaceShader')
mc.setAttr(redFM + '.color', 0.5, 0.0395, 0.0395, type='double3')
mc.setAttr(redFM + '.cosinePower', 20)
mc.setAttr(redFM + '.specularColor', 0.5, 0.0395, 0.0395, type='double3')
mc.setAttr(redFM + '.reflectivity', 0.8)
def clearPlastic():
### clear plastic
global cPlasticSG
cPlastic = mc.shadingNode('phong', asShader=True, n='cPlastic')
cPlasticSG = mc.sets(r=True, nss=True, em=True, n='cPlasticSG')
mc.connectAttr(cPlastic + '.outColor', cPlasticSG + '.surfaceShader')
mc.setAttr(cPlastic + '.color', 0.0, 0.0, 0.0, type='double3')
mc.setAttr(cPlastic + '.cosinePower', 20)
mc.setAttr(cPlastic + '.specularColor', 2.0, 2.0, 2.0, type='double3')
mc.setAttr(cPlastic + '.reflectivity', 0.5)
mc.setAttr(cPlastic + '.transparency', 0.6, 0.6, 0.6, type='double3')
def matGold():
gold = cmds.shadingNode('blinn', asShader=True)
cmds.setAttr(gold + '.color', 0.92, 0.74, 0.05, type='double3')
cmds.setAttr(gold + '.diffuse', 0.47)
cmds.setAttr(gold + '.translucence', 0)
cmds.setAttr(gold + '.translucenceDepth', 0)
cmds.setAttr(gold + '.translucenceFocus', 0)
cmds.setAttr(gold + '.eccentricity', 0.4)
cmds.setAttr(gold + '.specularRollOff', 0.7)
cmds.setAttr(gold + '.specularColor', 0.9, 0.72, 0.05, type='double3')
cmds.setAttr(gold + '.reflectivity', 0.239)
cmds.setAttr(gold + '.reflectedColor', 0.92, 0.74, 0.05, type='double3')
return gold
def chrome():
### blue clear plastic
global chromeSG
chrome = mc.shadingNode('phong', asShader=True, n='chrome')
chromeSG = mc.sets(r=True, nss=True, em=True, n='chromeSG')
mc.connectAttr(chrome + '.outColor', chromeSG + '.surfaceShader')
mc.setAttr(chrome + '.color', 0.0, 0.0, 0.0, type='double3')
mc.setAttr(chrome + '.transparency', 0.0, 0.0, 0.0, type='double3')
mc.setAttr(chrome + '.ambientColor', 1.0, 1.0, 1.0, type='double3')
mc.setAttr(chrome + '.incandescence', 0.122, 0.122, 0.122, type='double3')
mc.setAttr(chrome + '.cosinePower', 20)
mc.setAttr(chrome + '.specularColor', 2.0, 2.0, 2.0, type='double3')
mc.setAttr(chrome + '.reflectivity', 2.0)
def matBubble():
bub = cmds.shadingNode('blinn', asShader=True)
cmds.setAttr(bub + '.color', 0.16, 0.45, 0.45, type='double3')
cmds.setAttr(bub + '.transparency', 0.74, 0.74, 0.74, type='double3')
cmds.setAttr(bub + '.ambientColor', 0.2, 0.2, 0.2, type='double3')
cmds.setAttr(bub + '.diffuse', 0.8)
cmds.setAttr(bub + '.translucence', 0.658)
cmds.setAttr(bub + '.eccentricity', 0.3)
cmds.setAttr(bub + '.specularRollOff', 0.7)
cmds.setAttr(bub + '.specularColor', 1, 1, 1, type='double3')
cmds.setAttr(bub + '.reflectivity', 0.5)
cmds.setAttr(bub + '.reflectedColor', .13, .13, .13, type='double3')
return bub
def shinyGold():
### gold
global shinyGoldSG
chrome = mc.shadingNode('blinn', asShader=True, n='shinyGold')
shinyGoldSG = mc.sets(r=True, nss=True, em=True, n='ShinyGoldSG')
mc.connectAttr(chrome + '.outColor', shinyGoldSG + '.surfaceShader')
mc.setAttr(chrome + '.color', 0.75, 0.5, 0.12, type='double3')
mc.setAttr(chrome + '.transparency', 0.0, 0.0, 0.0, type='double3')
mc.setAttr(chrome + '.ambientColor', 0.75, 0.5, 0.12, type='double3')
mc.setAttr(chrome + '.incandescence', 0.122, 0.122, 0.122, type='double3')
#mc.setAttr(chrome+'.cosinePower', 20)
mc.setAttr(chrome + '.specularColor', 0.75, 0.50, 0.12, type='double3')
mc.setAttr(chrome + '.reflectivity', 2.0)
def silver():
### silver
global silverSG
silver = mc.shadingNode('blinn', asShader=True, n='silver')
silverSG = mc.sets(r=True, nss=True, em=True, n='silverSG')
mc.connectAttr(silver + '.outColor', silverSG + '.surfaceShader')
mc.setAttr(silver + '.color', 0.0, 0.0, 0.0, type='double3')
mc.setAttr(silver + '.transparency', 0.0, 0.0, 0.0, type='double3')
mc.setAttr(silver + '.ambientColor', 0.0, 0.0, 0.0, type='double3')
mc.setAttr(silver + '.incandescence', 0.122, 0.122, 0.122, type='double3')
#mc.setAttr(chrome+'.cosinePower', 20)
mc.setAttr(silver + '.specularColor', 1.0, 1.0, 1.0, type='double3')
mc.setAttr(silver + '.reflectivity', 2.0)
def matShinyAlum():
alum = cmds.shadingNode('blinn', asShader=True)
cmds.setAttr(alum + '.color', 0.6, 0.6, 0.6, type='double3')
cmds.setAttr(alum + '.diffuse', 0.44)
cmds.setAttr(alum + '.translucence', 0)
cmds.setAttr(alum + '.translucenceDepth', 0)
cmds.setAttr(alum + '.translucenceFocus', 0)
cmds.setAttr(alum + '.eccentricity', 0.419)
cmds.setAttr(alum + '.specularRollOff', 0.684)
cmds.setAttr(alum + '.specularColor', 1, 1, 1, type='double3')
cmds.setAttr(alum + '.reflectivity', 0.1)
cmds.setAttr(alum + '.reflectedColor', 0.22, 0.22, 0.22, type='double3')
return alum
def createShader(self, shaderName, shaderType ='blinn'):
shaderEngine = None
if not cmds.objExists(shaderName):
shader = cmds.shadingNode(shaderType, asShader=True)
shader = cmds.rename(shader, shaderName)
shaderEngine = cmds.sets(renderable=True, empty=True, noSurfaceShader=True, name=shader + '_SG')
cmds.connectAttr(shader + '.outColor', shaderEngine + '.surfaceShader')
else:
shader = shaderName
engines = cmds.listConnections(shader + '.outColor')
if engines:
shaderEngine = engines[0]
return shader, shaderEngine
def sword():
### silver
global swordSG
sword = mc.shadingNode('blinn', asShader=True, n='sword')
swordSG = mc.sets(r=True, nss=True, em=True, n='swordSG')
mc.connectAttr(sword + '.outColor', swordSG + '.surfaceShader')
mc.setAttr(sword + '.color', 1.0, 0.4, 0.7, type='double3')
mc.setAttr(sword + '.transparency', 0.0, 0.0, 0.0, type='double3')
mc.setAttr(sword + '.ambientColor', 0.0, 0.0, 0.0, type='double3')
mc.setAttr(sword + '.incandescence', 0.0, 0.0, 0.0, type='double3')
#mc.setAttr(chrome+'.cosinePower', 20)
mc.setAttr(sword + '.specularColor', 0.5, 0.5, 0.5, type='double3')
mc.setAttr(sword + '.reflectivity', 0.5)
mc.setAttr(sword + '.eccentricity', 0.3)
mc.setAttr(sword + '.glowIntensity', 1.0)
def __init__(self, name, r, g, b):
### blue clear plastic
blueCPlastic = mc.shadingNode('phong', asShader=True, n='blueCPlastic')
self.PlasticSG = mc.sets(r=True, nss=True, em=True, n='blueCPlasticSG')
mc.connectAttr(blueCPlastic + '.outColor',
self.PlasticSG + '.surfaceShader')
mc.setAttr(blueCPlastic + '.color', r, g, b, type='double3')
mc.setAttr(blueCPlastic + '.cosinePower', 20)
mc.setAttr(blueCPlastic + '.specularColor',
2.0,
2.0,
2.0,
type='double3')
mc.setAttr(blueCPlastic + '.reflectivity', 0.5)
mc.setAttr(blueCPlastic + '.transparency',
0.6,
0.6,
0.6,
type='double3')
def simulate(numFlockers, numFrames, alignmentWeight, cohesionWeight,
separationWeight, speed, distance, in3D):
# Create the flock
flock = Flock(alignmentWeight, cohesionWeight, separationWeight, speed,
distance)
cmds.shadingNode('phong', asShader=True, name='Redwax')
cmds.select('Redwax')
cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name='RedwaxSG')
cmds.connectAttr('Redwax.outColor', 'RedwaxSG.surfaceShader', f=True)
cmds.setAttr('Redwax.color', 1, 0, 0, type='double3')
cmds.setAttr('Redwax.cosinePower', 5)
cmds.setAttr('Redwax.reflectivity', 0)
cmds.setAttr('Redwax.specularColor', 1, 1, 1, type='double3')
cmds.shadingNode('blinn', asShader=True, name='Plastic')
cmds.select('Plastic')
cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name='PlasticSG')
cmds.connectAttr('Plastic.outColor', 'PlasticSG.surfaceShader', f=True)
cmds.setAttr('Plastic.color', 0.9, 0.9, 0.9, type='double3')
cmds.setAttr('Plastic.eccentricity', 0.55)
cmds.setAttr('Plastic.specularRollOff', 1)
cmds.setAttr('Plastic.diffuse', 0.9)
cmds.directionalLight(rotation=(-90, 0, 0))
cmds.polyPlane(name='base')
cmds.setAttr('base.scaleX', 25)
cmds.setAttr('base.scaleZ', 25)
cmds.setAttr('base.translateY', -15)
cmds.select('base')
cmds.sets(e=True, forceElement='PlasticSG')
for i in range(numFlockers):
xVel = random.randint(-9, 9)
yVel = random.randint(-9, 9)
zVel = random.randint(-9, 9)
xPos = random.randint(-100, 100)
yPos = random.randint(-100, 100)
zPos = random.randint(-100, 100)
fname = 'f' + str(i)
if (in3D):
flock.addFlocker(xVel, yVel, zVel, xPos, yPos, zPos, fname)
else:
flock.addFlocker(xVel, 0, zVel, xPos, 0, zPos, fname)
cmds.polySphere(name=fname, radius=0.2)
cmds.select(fname)
cmds.sets(e=True, forceElement='RedwaxSG')
# Initialize time
time = 0
endTime = numFrames
cmds.currentTime(time)
# Initialize flock member positions
for flocker in flock.flockers:
cmds.select(flocker.name)
cmds.move(flocker.xPos, flocker.yPos, flocker.zPos)
cmds.setKeyframe(flocker.name)
while time < endTime:
time += 12
for flocker in flock.flockers:
flocker.updateVelocity(flock)
for flocker in flock.flockers:
flocker.updatePostion()
cmds.currentTime(time)
for flocker in flock.flockers:
fx = flocker.name + '.translateX'
fy = flocker.name + '.translateY'
fz = flocker.name + '.translateZ'
cmds.setAttr(fx, flocker.xPos)
cmds.setAttr(fy, flocker.yPos)
cmds.setAttr(fz, flocker.zPos)
cmds.setKeyframe(flocker.name)
def setUpMolecule():
#Adjust time slider
cmds.playbackOptions( minTime='1', maxTime='300', mps=1)
# Create the oxygen part of the larger bond (cylinder)
cmds.polyCylinder(n='oxyCylinder', r=1, h=2, sx=20, sy=1, sz=1, ax=(1, 0, 0), rcp=0, cuv=3, ch=1)
#Set scale for oxyCylinder
cmds.setAttr("oxyCylinder.translateX", 6)
cmds.setAttr("oxyCylinder.scaleZ", 2)
cmds.setAttr("oxyCylinder.scaleX", 2)
cmds.setAttr("oxyCylinder.scaleY", 2)
#-------Set up shader and shade cylinder----------
redShader = cmds.shadingNode('blinn', asShader=True, n='redBlinn')
cmds.setAttr("redBlinn.color", 0.772, 0, 0, type="double3")
cmds.select('oxyCylinder')
cmds.hyperShade(assign=redShader)
#--------------White Cylinder-------------
# Create the oxygen part of the larger bond (cylinder)
cmds.polyCylinder(n='hydroCylinder', r=1, h=2, sx=20, sy=1, sz=1, ax=(1, 0, 0), rcp=0, cuv=3, ch=1)
#Set scale for oxyCylinder
cmds.setAttr("hydroCylinder.translateX", 10)
cmds.setAttr("hydroCylinder.scaleZ", 2)
cmds.setAttr("hydroCylinder.scaleX", 2)
cmds.setAttr("hydroCylinder.scaleY", 2)
#-------Set up shader and shade cylinder----------
whiteShader = cmds.shadingNode('blinn', asShader=True, n='whiteBlinn')
cmds.setAttr("whiteBlinn.color", 1, 1, 1, type="double3")
#Select the cylinder to color
cmds.select('hydroCylinder')
# Assign shader
cmds.hyperShade(assign=whiteShader)
#----------------------------------------------------------
#-----------Group two cylinders together as "cylinder"-----
#----------------------------------------------------------
cmds.group(em=True, n='cylinder')
cmds.parent('oxyCylinder', 'cylinder')
cmds.parent('hydroCylinder', 'cylinder')
#------------Oxygen-------------
# Create the Oxygen sphere
cmds.polySphere(n='oxygen', r=1, sx=20, sy=20, ax=(0, 1, 0), cuv=2, ch=1)
#Set scale for oxygen
cmds.setAttr("oxygen.scaleZ", 5)
cmds.setAttr("oxygen.scaleX", 5)
cmds.setAttr("oxygen.scaleY", 5)
#-------Assign shader--------
cmds.select('oxygen')
cmds.hyperShade(assign=redShader)
#------------Hydrogen-------------
# Create the Hydrogen sphere
cmds.polySphere(n='hydrogen', r=1, sx=20, sy=20, ax=(0, 1, 0), cuv=2, ch=1)
#Set scale for oxygen
cmds.setAttr("hydrogen.translateX", 14)
cmds.setAttr("hydrogen.scaleZ", 4)
cmds.setAttr("hydrogen.scaleX", 4)
cmds.setAttr("hydrogen.scaleY", 4)
#-------Assign shader--------
cmds.select('hydrogen')
cmds.hyperShade(assign=whiteShader)
#----------------------------------------------------------
#-----------Group 'cylinder' and hydrogen together as "hydroAssembly"-----
#----------------------------------------------------------
cmds.group(em=True, n='hydroAssembly1')
cmds.parent('cylinder', 'hydroAssembly1')
cmds.parent('hydrogen', 'hydroAssembly1')
#----------------------------------------------------------
#-----------Group into realign group
#----------------------------------------------------------
cmds.group(em=True, n='realignGroup1')
cmds.parent('hydroAssembly1', 'realignGroup1')
#-------------------------------------------------------------
#------------Duplicate the assembly--------------------------
#-------------------------------------------------------------
cmds.duplicate('realignGroup1', n='realignGroup2')
cmds.setAttr('realignGroup2.rotateZ', 180)
cmds.rename('realignGroup2|hydroAssembly1','hydroAssembly2')
#----------------------------------------------------------
#-----------Make entire thing a group "molecule"-----
#----------------------------------------------------------
cmds.group(em=True, n='molecule')
cmds.parent('oxygen', 'molecule')
cmds.parent('realignGroup1', 'molecule')
cmds.parent('realignGroup2', 'molecule')
#-------Move entire molecule up-------
cmds.setAttr("molecule.translateY", 10)
def create_bubbles():
size = rand(0.01, 0.04)
cmds.scale(0.1, 0.3, 0.1)
cmds.move(0, 0.4, 0)
cube = cmds.polyCube(w=5, d=5, h=4)
cmds.move(0, 1.5, 0)
cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name='ph' + 'SG')
myShader = cmds.shadingNode('phongE', asShader=True, name='ph')
#cmds.shadingNode('lambert', name= 'ph', asShader= True)
cmds.setAttr(myShader + '.color', 0, 1, 1, type='double3')
cmds.setAttr(myShader + '.transparency', 1, 0.6, 0.6, type='double3')
cmds.select(cube)
cmds.hyperShade(assign=myShader)
#cmds.displaySurface(xRay=True)
#cmds.connectAttr('ph'+'.outColor', 'ph'+'SG.surfaceShader')
#cmds.sets(cube, edit=True, forceElement='ph'+'SG')
#cmds.move (0, 2, 0)
for i in range(20):
# set playback range
cmds.playbackOptions(minTime=i + rand(1, 4), maxTime='72')
bubble = cmds.polySphere(name='bubble' + str(i),
radius=rand(0.2, 0.4)) # create a sphere
cmds.move(rand(-2, 2), rand(-2, 2), rand(-2, 2))
cmds.select('bubble' + str(i))
cmds.lattice(dv=(5, 6, 5), oc=True)
cmds.select('ffd' + str(i + 1) + 'Lattice.pt[0:3][0:1][2]',
'ffd' + str(i + 1) + 'Lattice.pt[4][1][2]',
'ffd' + str(i + 1) + 'Lattice.pt[0:4][2:5][2]',
r=True)
cmds.scale(0.33, 0.33, 0.33, relative=True)
cmds.select('ffd' + str(i + 1) + 'Lattice.pt[0][1][3]',
'ffd' + str(i + 1) + 'Lattice.pt[2][3][4]',
r=True)
cmds.move(0, 0, -0.05, relative=True)
cmds.select('ffd' + str(i + 1) + 'Lattice.pt[2][3][0]')
cmds.move(0, 0, 0.8, relative=True)
#cmds.select('bubble'+str(i))
for time in [1, 15, 30, 45, 60,
72]: # for each frame calculate sub-steps
#mc.setKeyframe( bubble, attribute='translateX', value=px, t=f ) # set keyframes
cmds.setKeyframe(bubble,
attribute='translateY',
value=0.002 * time * i,
t=time)
cmds.setKeyframe(bubble,
attribute='scaleX',
value=size + 0.001 * time * i,
t=time)
cmds.setKeyframe(bubble,
attribute='scaleY',
value=size + 0.001 * time * i,
t=time)
cmds.setKeyframe(bubble,
attribute='scaleZ',
value=size + 0.001 * time * i,
t=time)
def _handleExample1Button(self):
"""
This callback creates a polygonal cylinder in the Maya scene.
r = 50
a = 2.0*r
y = (0, 1, 0)
c = cmds.polyCylinder(
r=r, h=5, sx=40, sy=1, sz=1, ax=y, rcp=0, cuv=2, ch=1, n='exampleCylinder')[0]
cmds.select(c)
response = nimble.createRemoteResponse(globals())
response.put('name', c)
"""
cmds.select(allDagObjects=True)
cmds.pointLight(rgb=(1, 1, 0.5))
cmds.move(-10, 15, 14)
cmds.pointLight(rgb=(1, 0.1, 0.2))
cmds.move(-8, 15, -10)
cmds.pointLight(rgb=(1, 0.1, 0.2))
cmds.move(-12, 15, 3)
material = str(self.comboBox.currentText())
object3 = str(self.comboBox_2.currentText())
print material
array = ['plastic1', 'plastic2', 'red', 'gold', 'silver', 'bronze']
object = ['captain', 'soldiers', 'carpet']
print array
# material 1
#plastic1 = "plastic1"
plastic1 = cmds.shadingNode('blinn', asShader=True)
cmds.setAttr("%s.color" % plastic1, 0.95, 0.95, 0.95, type="double3")
cmds.setAttr("%s.incandescence" % plastic1,
0.5,
0.5,
0.5,
type="double3")
#cmds.setAttr("%s.transparency" % plastic1, 0.75, 0.75, 0.75, type="double3")
#cmds.setAttr("%s.incandescence" % plastic1,0.5, 0.5, 0.5, type="double3")
# material 2
plastic2 = cmds.shadingNode('lambert', asShader=True)
cmds.sets(name="%sSG" % plastic2,
renderable=True,
noSurfaceShader=True,
empty=True)
cmds.connectAttr("%s.outColor" % plastic2,
"%sSG.surfaceShader" % plastic2)
cmds.setAttr("%s.color" % plastic2, 0.1, 1.0, 0.2, type="double3")
#cmds.setAttr("%s.transparency" % plastic2,0.75, 0.75, 0.75, type="double3")
cmds.setAttr("%s.incandescence" % plastic2,
0.5,
0.5,
0.5,
type="double3")
# material 3
red = cmds.shadingNode('blinn', asShader=True)
cmds.setAttr("%s.color" % red, 1.0, 0.1, 0.1, type="double3")
#cmds.setAttr("%s.transparency" % plastic1, 0.75, 0.75, 0.75, type="double3")
#cmds.setAttr("%s.incandescence" % plastic1,0.5, 0.5, 0.5, type="double3")
# material 4
#metal1 = 'metal1'
gold = cmds.shadingNode('blinn', asShader=True)
cmds.setAttr("%s.color" % gold, 1.0, 0.8, 0.0, type="double3")
# material 5
silver = cmds.shadingNode('blinn', asShader=True)
#cmds.setAttr("%s.color" % silver, 0.75, 075, 0.75, type="double3")
cmds.setAttr("%s.color" % silver, 0.9, 0.9, 1.0, type="double3")
# material 6
bronze = cmds.shadingNode('blinn', asShader=True)
cmds.setAttr("%s.color" % bronze, 0.8, 0.5, 0.2, type="double3")
cmds.select(object3)
if (material == array[0]):
cmds.hyperShade(assign=plastic1)
elif (material == array[1]):
cmds.hyperShade(assign=plastic2)
elif (material == array[2]):
cmds.hyperShade(assign=red)
elif (material == array[3]):
cmds.hyperShade(assign=gold)
elif (material == array[4]):
cmds.hyperShade(assign=silver)
elif (material == array[5]):
cmds.hyperShade(assign=bronze)
def createMaterial( name, color, type ):
cmds.sets( renderable=True, noSurfaceShader=True, empty=True, name=name + 'SG' )
cmds.shadingNode( type, asShader=True, name=name )
cmds.setAttr( name+'.color', color[0], color[1], color[2], type='double3')
cmds.connectAttr(name+'.outColor', name+'SG.surfaceShader')
