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 getTrackManagerNode(cls, trackSetNode =None, createIfMissing =False): """ Returns the name of the track manager nodeName for the current Cadence scene. trackSetNode: The track set nodeName on which to find the track manager nodeName. If no nodeName is specified the method will look it up internally. createIfMissing: If true and no track manager nodeName is found one will be created and connected to the track set nodeName, which will also be created if one does not exist. """ if not trackSetNode: trackSetNode = cls.getTrackSetNode(createIfMissing=createIfMissing) connects = cmds.listConnections( trackSetNode + '.usedBy', source=True, destination=False) if connects: for node in connects: if cmds.nodeType(node) == 'trackManager': return node if createIfMissing: node = cmds.createNode('trackManager') cmds.connectAttr( node + '.trackSet', trackSetNode + '.usedBy', force=True) return node return None
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 remove(cls): prints = cls.getTargets(1) if not prints: return False for p in prints: if not cmds.attributeQuery(cls._PREVIOUS_PRINT_ATTR, node=p, exists=True): print 'UNRECOGNIZED ITEM: "%s" is not a valid footprint and has been skipped.' % p continue nexts = cls.getNext(p) for c in nexts: cmds.disconnectAttr(p + '.message', c + '.' + cls._PREVIOUS_PRINT_ATTR) prevs = cls.getPrevious(p) for c in prevs: try: cmds.disconnectAttr(c + '.message', p + '.' + cls._PREVIOUS_PRINT_ATTR) except Exception, err: print 'DISCONNECT FAILURE | Unable to disconnect' print '\tTarget:', str(p) + '.' + cls._PREVIOUS_PRINT_ATTR print '\tSource:', str(c) + '.message' raise cmds.deleteAttr(p + '.' + cls._PREVIOUS_PRINT_ATTR) cmds.connectAttr( prevs[0] + '.message', nexts[0] + '.' + cls._PREVIOUS_PRINT_ATTR, force=True )
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 __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 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 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 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 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 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 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 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 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 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 build(cls): prints = cls.getTargets(2) if not prints or len(prints) < 2: return False prev = prints[0] for p in prints[1:]: if not cmds.attributeQuery(cls._PREVIOUS_PRINT_ATTR, node=p, exists=True): cmds.addAttr(longName=cls._PREVIOUS_PRINT_ATTR, attributeType='message') prevs = cls.getPrevious(p) if not prevs or prev not in prevs: cmds.connectAttr(prev + '.message', p + '.' + cls._PREVIOUS_PRINT_ATTR, force=True) prev = p return True
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 _createMeshPointNode(self, shapeData): self._removeMeshPointNode() try: node = cmds.createNode('closestPointOnMesh', skipSelect=True) self._meshPointNode = node except Exception as err: print(Logger.createErrorMessage(u'ERROR: Unable to create mesh point node', err)) self._removeMeshPointNode() return False try: cmds.connectAttr(shapeData['name'] + '.message', node + '.inMesh', force=True) except Exception as err: print(Logger.createErrorMessage(u'ERROR: Unable to connect mesh point node to shape', err)) self._removeMeshPointNode() return False return True
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 createToken(cls, uid, props, trackSetNode =None): """ A token is created, provided with some additional Maya attributes, and placed in the scene. Tokens are functtionally similar to TrackNodes, but with different shapes and attributes. """ cylinderHeight = 5.0 coneHeight = 10.0 if not trackSetNode: trackSetNode = TrackSceneUtils.getTrackSetNode() if not trackSetNode: return None node = cls.getTrackNode(uid, trackSetNode=trackSetNode) if node: return node # determine whether left or right, and manus or pes, from name name = props['name'] if props else None if not name: print('createToken: No properties specified') return # remove '_proxy' or '_token' if present (as in S6_LP3_proxy) nameFields = cls.decomposeName(name.split('_')[0]) isLeft = nameFields['left'] isPes = nameFields['pes'] # make a cone for the token of an proxy else a cylinder if uid.endswith('_proxy'): node = cmds.polyCone( radius=0.5, height=coneHeight, subdivisionsX=10, subdivisionsY=1, subdivisionsZ=1, axis=(0, 1, 0), createUVs=0, constructionHistory=0, name='Token_0')[0] cmds.move(0, 0.5 * coneHeight, 0) else: node = cmds.polyCylinder( radius=0.5, height=cylinderHeight, subdivisionsX=10, subdivisionsY=1, subdivisionsZ=1, subdivisionsCaps=0, axis=(0, 1, 0), createUVs=0, constructionHistory=0, name='Token_0')[0] cmds.move(0, 0.5 * cylinderHeight, 0) # Set up the basic cadence attributes cmds.addAttr(longName='cadence_dx', shortName='dx', niceName='DX') cmds.addAttr(longName='cadence_dy', shortName='dy', niceName='DY') cmds.addAttr( longName='cadence_uniqueId', shortName='track_uid', dataType='string', niceName='UID') cmds.addAttr( longName='cadence_name', shortName='token_name', dataType='string', niceName='Name') # Disable some transform attributes cmds.setAttr(node + '.rotateX', lock=True) cmds.setAttr(node + '.rotateZ', lock=True) cmds.setAttr(node + '.scaleY', lock=True) cmds.setAttr(node + '.translateY', lock=True) # Scale the cylinder/cone in x and z to represent 'dy' and 'dx' in # centimeters. There is a change of coordinates between Maya (X, Z) and # the simulator (X, Y) space. For example, for the right manus: # x = int(100*float(entry['rm_y'])) # z = int(100*float(entry['rm_x'])) # and likewise for dx and dy. # the DX and DY attributes affect scaleZ and scaleX in the node cmds.connectAttr(node + '.dx', node + '.scaleZ') cmds.connectAttr(node + '.dy', node + '.scaleX') # add a short annotation based on the name annotation = cmds.annotate(node, text=cls.shortName(props['name'])) cmds.select(annotation) aTransform = cmds.pickWalk(direction='up')[0] # control it's position by that of the node, so that it stays 15 cm # above the pes and 10 cm above the manus if isPes: cmds.move(0.0, 15.0, 0.0, aTransform) else: cmds.move(0.0, 10.0, 0.0, aTransform) cmds.connectAttr(node + '.translateX', aTransform + '.translateX') cmds.connectAttr(node + '.translateZ', aTransform + '.translateZ') # and make it non-selectable cmds.setAttr(aTransform + '.overrideEnabled', 1) cmds.setAttr(aTransform + '.overrideDisplayType', 2) cmds.rename(aTransform, "TokenAnnotation_0") if isPes: if isLeft: color = TrackwayShaderConfig.LEFT_PES_TOKEN_COLOR else: color = TrackwayShaderConfig.RIGHT_PES_TOKEN_COLOR else: if isLeft: color = TrackwayShaderConfig.LEFT_MANUS_TOKEN_COLOR else: color = TrackwayShaderConfig.RIGHT_MANUS_TOKEN_COLOR ShadingUtils.applyShader(color, node) cmds.select(node) # add the new node to the Cadence track set cmds.sets(node, add=trackSetNode) # finally, initialize all the properties from the dictionary props cls.setTokenProps(node, props) return node
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 createTrackNode(cls, uid, trackSetNode =None, props =None): """ A track node consists of a triangular pointer (left = red, right = green) which is selectable but only allows rotateY, translateX, and translateZ. The node has a child, a transform called inverter, which serves to counteract the scaling in x and z that is applied to the triangular node. There are two orthogonal rulers (width and length). Width and length uncertainty is represented by rectangular bars at the ends of the rulers. In Maya one can directly adjust track position (translateX and translateZ) and orientation (rotationY); other attributes are adjusted only through the UI. """ if not trackSetNode: trackSetNode = TrackSceneUtils.getTrackSetNode() if not trackSetNode: return None node = cls.getTrackNode(uid, trackSetNode=trackSetNode) if node: return node # Set up dimensional constants for the track node nodeThickness = 1.0 thetaBreadth = 0.1 thetaThickness = 0.5 barBreadth = 2.0 barThickness = 0.5 rulerBreadth = 1.0 rulerThickness = 0.25 epsilon = 1.0 # Create an isoceles triangle pointer, with base aligned with X, and # scaled by node.width. The midpoint of the base is centered on the # 'track center' and the altitude extends from that center of the track # 'anteriorly' to the perimeter of the track's profile (if present, else # estimated). The node is scaled longitudinally (in z) based on the # distance zN (the 'anterior' length of the track, in cm). The triangle # is initially 1 cm on a side. sideLength = 1.0 node = cmds.polyPrism( length=nodeThickness, sideLength=sideLength, numberOfSides=3, subdivisionsHeight=1, subdivisionsCaps=0, axis=(0, 1, 0), createUVs=0, constructionHistory=0, name='Track0')[0] # Point the triangle down the +Z axis cmds.rotate(0.0, -90.0, 0.0) # push it down below ground level so that the two rulers are just # submerged, and scale the triangle in Z to match its width (1 cm) so it # is ready to be scaled cmds.move(0, -(nodeThickness/2.0 + rulerThickness), math.sqrt(3.0)/6.0) # move the node's pivot to the 'base' of the triangle so it scales # outward from that point cmds.move( 0, 0, 0, node + ".scalePivot", node + ".rotatePivot", absolute=True) cmds.scale(2.0/math.sqrt(3.0), 1.0, 100.0) cmds.makeIdentity( apply=True, translate=True, rotate=True, scale=True, normal=False) # Set up the cadence attributes cmds.addAttr( longName='cadence_width', shortName=TrackPropEnum.WIDTH.maya, niceName='Width') cmds.addAttr( longName='cadence_widthUncertainty', shortName=TrackPropEnum.WIDTH_UNCERTAINTY.maya, niceName='Width Uncertainty') cmds.addAttr( longName='cadence_length', shortName=TrackPropEnum.LENGTH.maya, niceName='Length') cmds.addAttr( longName='cadence_lengthUncertainty', shortName=TrackPropEnum.LENGTH_UNCERTAINTY.maya, niceName='Length Uncertainty') cmds.addAttr( longName='cadence_lengthRatio', shortName=TrackPropEnum.LENGTH_RATIO.maya, niceName='Length Ratio') cmds.addAttr( longName='cadence_rotationUncertainty', shortName=TrackPropEnum.ROTATION_UNCERTAINTY.maya, niceName='Rotation Uncertainty') cmds.addAttr( longName='cadence_uniqueId', shortName=TrackPropEnum.UID.maya, dataType='string', niceName='Unique ID') # Construct a ruler representing track width, then push it down just # below ground level, and ake it non-selectable. Drive its scale by the # node's width attribute. widthRuler = cmds.polyCube( axis=(0, 1, 0), width=100.0, height=rulerThickness, depth=rulerBreadth, subdivisionsX=1, subdivisionsY=1, createUVs=0, constructionHistory=0, name='WidthRuler')[0] # Push it down to just rest on the triangular node (which is already # submerged by the thickness of the ruler and half the node thickness. cmds.move(0.0, -rulerThickness/2.0, 0.0) cmds.setAttr(widthRuler + '.overrideEnabled', 1) cmds.setAttr(widthRuler + '.overrideDisplayType', 2) # Construct a ruler representing track length and push it down the same # as the width ruler, and make it non-selectable. Its length will be # driven by the node's length attribute. lengthRuler = cmds.polyCube( axis=(0, 1, 0), width=rulerBreadth, height=rulerThickness, depth=100.0, subdivisionsX=1, subdivisionsY=1, createUVs=0, constructionHistory=0, name='LengthRuler')[0] cmds.move(0.0, -rulerThickness/2.0, 0.0) cmds.setAttr(lengthRuler + '.overrideEnabled', 1) cmds.setAttr(lengthRuler + '.overrideDisplayType', 2) # Now construct 'error bars' to the North, South, West, and East of the # node, to visualize uncertainty in width (West and East bars) and # length (North and South bars), and push them just below ground level, # and make them non-selectable. barN = cmds.polyCube( axis=(0,1,0), width=barBreadth, height=barThickness, depth=100.0, subdivisionsX=1, subdivisionsY=1, createUVs=0, constructionHistory=0, name='BarN')[0] cmds.move(0, -(barThickness/2 + rulerThickness), 0) cmds.setAttr(barN + '.overrideEnabled', 1) cmds.setAttr(barN + '.overrideDisplayType', 2) barS = cmds.polyCube( axis=(0, 1, 0), width=barBreadth, height=barThickness, depth=100.0, subdivisionsX=1, subdivisionsY=1, createUVs=0, constructionHistory=0, name='BarS')[0] cmds.move(0, -(barThickness/2 + rulerThickness), 0) cmds.setAttr(barS + '.overrideEnabled', 1) cmds.setAttr(barS + '.overrideDisplayType', 2) barW = cmds.polyCube( axis=(0, 1, 0), width=100.0, height=barThickness, depth=barBreadth, subdivisionsX=1, subdivisionsY=1, createUVs=0, constructionHistory=0, name='BarW')[0] cmds.move(0, -(barThickness/2 + rulerThickness), 0) cmds.setAttr(barW + '.overrideEnabled', 1) cmds.setAttr(barW + '.overrideDisplayType', 2) barE = cmds.polyCube( axis=(0, 1, 0), width=100.0, height=barThickness, depth=barBreadth, subdivisionsX=1, subdivisionsY=1, createUVs=0, constructionHistory=0, name='BarE')[0] cmds.move(0, -(barThickness/2 + rulerThickness), 0) cmds.setAttr(barE + '.overrideEnabled', 1) cmds.setAttr(barE + '.overrideDisplayType', 2) # Create two diverging lines that indicate rotation uncertainty (plus # and minus), with their pivots placed so they extend from the node # center, and each is made non-selectable. First make the indicator of # maximum (counterclockwise) estimated track rotation thetaPlus = cmds.polyCube( axis=(0, 1, 0), width=thetaBreadth, height=thetaThickness, depth=1.0, subdivisionsX=1, subdivisionsY=1, createUVs=0, constructionHistory=0, name='ThetaPlus')[0] cmds.setAttr(thetaPlus + '.overrideEnabled', 1) cmds.setAttr(thetaPlus + '.overrideDisplayType', 2) # Next, construct the indicator of the minimum (clockwise) estimate of # track rotation thetaMinus = cmds.polyCube( axis=(0, 1, 0), width=thetaBreadth, height=thetaThickness, depth=1.0, subdivisionsX=1, subdivisionsY=1, createUVs=0, constructionHistory=0, name='ThetaMinus')[0] cmds.setAttr(thetaMinus + '.overrideEnabled', 1) cmds.setAttr(thetaMinus + '.overrideDisplayType', 2) # The two width 'error bars' will be translated outward from the node # center. First, the width attribute is converted from meters (as it # comes from the database) to centimeters; the computation is available # in the output of the node 'width'. width = cmds.createNode('multiplyDivide', name='width') cmds.setAttr(width + '.operation', 1) cmds.setAttr(width + '.input1X', 100.0) cmds.connectAttr( node + '.' + TrackPropEnum.WIDTH.maya, width + '.input2X') # Translate barW in x by width/2.0; output is in xW.outputX xW = cmds.createNode('multiplyDivide', name = 'xW') cmds.setAttr(xW + '.operation', 2) cmds.connectAttr(width + '.outputX', xW + '.input1X') cmds.setAttr(xW + '.input2X', 2.0) cmds.connectAttr(xW + '.outputX', barW + '.translateX') # Translate barE in x by -width/2.0; output is in xE.outputX xE = cmds.createNode('multiplyDivide', name = 'xE') cmds.setAttr(xE + '.operation', 2) # division operation cmds.connectAttr(width + '.outputX', xE + '.input1X') cmds.setAttr(xE + '.input2X', -2.0) cmds.connectAttr(xE + '.outputX', barE + '.translateX') # Now regarding length, first convert the node.length attribute from # meters to centimeters. This computation is available in the output of # the node 'length' length = cmds.createNode('multiplyDivide', name='length') cmds.setAttr(length + '.operation', 1) cmds.setAttr(length + '.input1X', 100.0) cmds.connectAttr( node + '.' + TrackPropEnum.LENGTH.maya, length + '.input2X') # scale thetaPlus and thetaMinus by length (since they are 1 cm, # multiply by length in cm) cmds.connectAttr(length + '.outputX', thetaPlus + '.scaleZ') cmds.connectAttr(length + '.outputX', thetaMinus + '.scaleZ') # Then barN is translated forward in z by zN = lengthRatio*length # (centimeters) zN = cmds.createNode('multiplyDivide', name='zN') cmds.setAttr(zN + '.operation', 1) cmds.connectAttr( node + '.' + TrackPropEnum.LENGTH_RATIO.maya, zN + '.input1X') cmds.connectAttr(length + '.outputX', zN + '.input2X') cmds.connectAttr(zN + '.outputX', barN + '.translateZ') # Next, translate barS backward in z by (zN - length); output is in # zS.output1D zS = cmds.createNode('plusMinusAverage', name='sZ') cmds.setAttr(zS + '.operation', 2) cmds.connectAttr(zN + '.outputX', zS + '.input1D[0]') cmds.connectAttr(length + '.outputX', zS + '.input1D[1]') cmds.connectAttr(zS + '.output1D', barS + '.translateZ') # Next, compute the half length, hl = length/2.0 (centimeters) hl = cmds.createNode('multiplyDivide', name='hl') cmds.setAttr(hl + '.operation', 2) cmds.connectAttr(length + '.outputX', hl + '.input1X') cmds.setAttr(hl + '.input2X', 2.0) # Translate lengthRuler along z by zL = (zN - hl) (centimeters) zL = cmds.createNode('plusMinusAverage', name='zL') cmds.setAttr(zL + '.operation', 2) cmds.connectAttr(zN + '.outputX', zL + '.input1D[0]') cmds.connectAttr(hl + '.outputX', zL + '.input1D[1]') cmds.connectAttr(zL + '.output1D', lengthRuler + '.translateZ') # Scale the four 'error bars' to represent the width and length # uncertainties (centimeters) cmds.connectAttr( node + "." + TrackPropEnum.WIDTH_UNCERTAINTY.maya, barW + '.scaleX') cmds.connectAttr( node + "." + TrackPropEnum.WIDTH_UNCERTAINTY.maya, barE + '.scaleX') cmds.connectAttr( node + "." + TrackPropEnum.LENGTH_UNCERTAINTY.maya, barN + '.scaleZ') cmds.connectAttr( node + "." + TrackPropEnum.LENGTH_UNCERTAINTY.maya, barS + '.scaleZ') # Create an 'inverter' transform under which all the other parts are # hung as children, which counteracts scaling applied to its parent # triangular node. inverter = cmds.createNode('transform', name='inverter') # drive the inverter's .scaleX and .scaleZ as the inverse of the parent # node's scale values sx = cmds.createNode('multiplyDivide', name='sx') cmds.setAttr(sx + '.operation', 2) cmds.setAttr(sx + '.input1X', 1.0) cmds.connectAttr(node + '.scaleX', sx + '.input2X') cmds.connectAttr(sx + '.outputX', inverter + '.scaleX') sz = cmds.createNode('multiplyDivide', name='sz') cmds.setAttr(sz + '.operation', 2) cmds.setAttr(sz + '.input1X', 1.0) cmds.connectAttr(node + '.scaleZ', sz + '.input2X') cmds.connectAttr(sz + '.outputX', inverter + '.scaleZ') # Assemble the parts as children under the scale inverter node cmds.parent(lengthRuler, inverter) cmds.parent(widthRuler, inverter) cmds.parent(barN, inverter) cmds.parent(barS, inverter) cmds.parent(barW, inverter) cmds.parent(barE, inverter) cmds.parent(thetaPlus, inverter) cmds.parent(thetaMinus, inverter) cmds.parent(inverter, node) # Rotate thetaPlus and thetaMinus about the Y axis to indicate # rotational uncertainty cmds.connectAttr( node + '.' + TrackPropEnum.ROTATION_UNCERTAINTY.maya, node + '|' + inverter + '|' + thetaPlus + '.rotateY') neg = cmds.createNode('multiplyDivide', name='negative') cmds.setAttr(neg + '.operation', 1) cmds.setAttr(neg + '.input1X', -1.0) cmds.connectAttr( node + '.' + TrackPropEnum.ROTATION_UNCERTAINTY.maya, neg + '.input2X') cmds.connectAttr( neg + '.outputX', node + '|' + inverter + '|' + thetaMinus + '.rotateY') # Disable some transforms of the node cmds.setAttr(node + '.rotateX', lock=True) cmds.setAttr(node + '.rotateZ', lock=True) cmds.setAttr(node + '.scaleY', lock=True) cmds.setAttr(node + '.translateY', lock=True) # Now, the width of the triangle will be driven by its width attribute # (driving .scaleX) cmds.connectAttr(node + '.width', node + '.scaleX') # The quantity zN is used to scale length of the triangle cmds.connectAttr(zN + '.outputX', node + '.scaleZ') # Scale the 'length' (in x) of the width ruler cmds.connectAttr( node + '.width', node + '|' + inverter + '|WidthRuler.scaleX') # Scale the length of the length ruler cmds.connectAttr( node + '.length', node + '|' + inverter + '|LengthRuler.scaleZ') # Translate the track node epsilon below ground level (to reveal the # overlaid track siteMap) cmds.move(0, -epsilon, 0, node) # Initialize all the properties from the dictionary if props: cls.setTrackProps(node, props) else: print('in createTrackNode: properties not provided') return node # Add the new nodeName to the Cadence track scene set, color it, and # we're done cmds.sets(node, add=trackSetNode) cls.colorTrackNode(node, props) return node
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 _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)