예제 #1
1
def _buildSpeedExpression(boatWorldCtrl = ''):
    """
    Builds the base expression for the boats world_ctrl speed attr
    @param boatWorldCtrl: The name of the boat world_ctrl to build the expression for
    @type boatWorldCtrl: String
    """
    expStringList = [
                    'float $time;\n',
                    'float $translation[] = `xform -q -ws -translation "%s"`;\n' % boatWorldCtrl,
                    'float $trx;\n',
                    'float $try;\n',
                    'float $trz;\n',
                    'float $dx = $translation[0] - $trx;\n',
                    'float $dy = $translation[1] - $try;\n',
                    'float $dz = $translation[2] - $trz;\n',
                    'float $d = sqrt( ($dx * $dx) + ($dy * $dy) + ($dz * $dz) );\n',
                    '%s.speed = abs( $d / ( time - ($time + 0.001) ) );\n' % boatWorldCtrl,
                    '$trx = $translation[0];\n',
                    '$try = $translation[1];\n',
                    '$trz = $translation[2];\n',
                    '$time = time;\n'
                    ]

    ## Check if the expression already exists in the scene, if so delete it
    utils.checkExpressionExists( '%s_speed' % boatWorldCtrl)
    ## Build new expression
    try:
        cmds.expression(n = '%s_speed' % boatWorldCtrl.replace(':', '_'), string = utils.processExpressionString(expStringList))
    except:
        cmds.warning('YOU ARE USING OLD RIGS!!! PLEASE UPDATE YOUR RIGS!!!')
    def __setExpression(self, footCtl, insideRollGrp, outsideRollGrp,
                        forward_roll, backward_roll):
        expression = """
        if (footCtl.side < 0.0) 
            insideRollGrp.rotateZ = footCtl.side;
        else
            insideRollGrp.rotateZ = 0.0;

        if (footCtl.side > 0.0) 
            outsideRollGrp.rotateZ = footCtl.side;
        else
            outsideRollGrp.rotateZ = 0.0;
        
        if (footCtl.roll < 0.0)
            backward_roll.rotateX = footCtl.roll;
        else
            backward_roll.rotateX = 0.0;
        
        if (footCtl.roll > 0.0)
            forward_roll.rotateX = footCtl.roll;
        else
            forward_roll.rotateX = 0.0;
            
        forward_roll.rotateY = footCtl.rotY;    
        """.replace('footCtl', footCtl).\
            replace('insideRollGrp', insideRollGrp).\
            replace('outsideRollGrp', outsideRollGrp).\
            replace('forward_roll', forward_roll).\
            replace('backward_roll', backward_roll)

        mc.expression(s=expression,
                      object=footCtl,
                      alwaysEvaluate=1,
                      unitConversion='all')
예제 #3
0
    def generate(self):
        self.m_fingers = []
        names = ["indexFing", "middleFing", "ringFing", "pinkyFing", "thumb"]
        for i in range(len(names)):
            thumb = False
            if i == (len(names) - 1):
                thumb = True
            newFinger = fing.FingerRig(
                "%s_%s" %(self.m_name, names[i]),
                self.m_handJoints.getFinger(i),
                thumb
                )
            newFinger.generate()
            cmds.parent(newFinger.getGroup(), self.m_group)
            self.m_fingers.append(newFinger)

        #create control
        self.m_control = cmds.spaceLocator(n="%s_CTRL" %(self.m_name))[0]


        rc.orientControl(self.m_control, self.m_fingers[3].getKnuckle())
        group = rg.addGroup(self.m_control, "%s_0" %(self.m_control))
        rc.lockAttrs(self.m_control, ["tx", "rotate", "scale"], True, False)
        cmds.parent(group, self.m_group)
        cmds.expression(n="%s_EXP" %(self.m_name), s=self.createExp())
def _buildNURBSPlaneExpression(NURBSPlane, xRes, zRes, oceanShader):
    """
    Function to setup the expression that hooks the nurbsPlane to the ocean
    @param NURBSPlane: The build of the nurbsPlane, this build command should have returned a list. Due to refactoring we're just handling this list instead of accepting the actual name
    @type NURBSPlane: List
    """
    ## Now build the expression to connect the cv's of the NURBSPlane to the ocean
    xSize = xRes+1
    zSize = zRes+1

    expStringList = ['float $u, $v;\n float $minx = %s.scaleX * -0.5 + %s.translateX;\n' % (NURBSPlane[0], NURBSPlane[0]),
                                'float $maxx = %s.scaleX *  0.5 + %s.translateX;\n' % (NURBSPlane[0], NURBSPlane[0]),
                                'float $minz = %s.scaleZ * -0.5 + %s.translateZ;\n' % (NURBSPlane[0], NURBSPlane[0]),
                                'float $maxz = %s.scaleZ *  0.5 + %s.translateZ;\n' % (NURBSPlane[0], NURBSPlane[0]),
                                'float $disp[] = `colorAtPoint -o A -su %s  -sv  %s -mu $minx -mv $minz -xu $maxx -xv $maxz %s`;\n' % (str(xSize), str(zSize), oceanShader)
                                ]
    expString = utils.processExpressionString(expStringList)
    #unfold loop and use output connections
    i=0
    for x in range(xSize):
        planeX = x * zSize
        for z in range(zSize):
            planeZ= zSize - z - 1
            addTo = "%s.cv[%s].yv = $disp[%s];\n" % (NURBSPlane[0], str(planeX +planeZ), str(i))
            expString += addTo
            #increment by 1
            i=i+1

    ## Check if the expression already exists in the scene, if so delete it
    utils.checkExpressionExists( '%s_IntersectionPlane' % NURBSPlane[0])

    ## Build new expression
    cmds.expression(n = '%s_IntersectionPlane' % '_'.join(NURBSPlane[0].split(':')), string = expString)
예제 #5
0
def eyeRig(scaler): #try 4
    target = mc.ls(sl=1)
    mc.delete(e=True)
    for i in range(0,len(target)):
        if(i<len(target)-1):
            mc.expression(s=target[i]+".rotateX = " + target[len(target)-1] + ".translateY * -1 * " + str(scaler))
            mc.expression(s=target[i]+".rotateY = " + target[len(target)-1] + ".translateX * " + str(scaler))
예제 #6
0
def rotationExpression():
    """This function adds an expression that allows the tread to rotate while moving"""

    cmds.select(data.mainController)
    cmds.addAttr(data.mainController, longName="treadSpeed", attributeType="double", defaultValue=20, keyable=True)

    cmds.expression(name="TreadRotation", string="{0}.rotateX = -{1}.translateZ*{1}.treadSpeed".format(data.treadBaseWire, data.mainController))
예제 #7
0
def turntable():
    """
    Main function. Creates turntable. Requires a list of selected objects.
    :return: None
    """
    objs = cmds.ls(selection=True)
    meshes = checkSelection(objs)
    if not meshes:
        cmds.error('Please select a mesh object')
    pivlist = getSelectionPivot(meshes)
    turnCam = createCamera()
    centroid = findCentroid(pivlist)

    # change camera pivot to centroid
    cmds.xform(turnCam[0], ws=True, piv=centroid)

    # animate camera. rotate around y axis.
    firstFrame = str(cmds.playbackOptions(q=True, minTime=True))
    lastFrame = str(cmds.playbackOptions(q=True, maxTime=True))
    cmds.expression(name='TurnTableExpression',
                    string='{0}.rotateY=360*(frame-{1})/{2}-{1};'.format(turnCam[0],
                                                                         firstFrame, lastFrame))

    # create a 3 point light rig.
    keyLight = createLight('areaLight', 'key', centroid)
    fillLight = createLight('areaLight', 'fill', centroid)
    rimLight = createLight('areaLight', 'rim', centroid)
    cmds.lookThru(turnCam[0])
예제 #8
0
def createSSLocator(tag, camera):
    #check if camera exists
    if not cmds.objExists(camera):
        raise RuntimeError('Camera doesn\'t exists in the scene')
    # create locator
    locator_name = tag + '_2D_loc1'
    loc = cmds.spaceLocator(name=locator_name)[0]
    loc_shape = cmds.listRelatives(loc, s=True)[0]
    cmds.setAttr(loc_shape + '.localScaleX', 0.1)
    cmds.setAttr(loc_shape + '.localScaleY', 0.1)
    cmds.setAttr(loc_shape + '.localScaleZ', 0.1)

    # add attributes
    cmds.addAttr(loc, ln='cam_x_value', at='double', dv=0, k=True)
    cmds.addAttr(loc, ln='cam_y_value', at='double', dv=0, k=True)
    #matrix_nodes
    mmn = cmds.createNode('multMatrix', name=tag + '_2D_mmn1')
    cmds.connectAttr(loc + '.worldMatrix[0]', mmn + '.matrixIn[0]')
    cmds.connectAttr(camera + '.worldInverseMatrix[0]', mmn + '.matrixIn[1]')
    dmn = cmds.createNode('decomposeMatrix', name=tag + '_2D_dmn1')
    cmds.connectAttr(mmn + '.matrixSum', dmn + '.inputMatrix')

    #add script to locator
    cmds.expression(name=tag + '_2D_exp1',
                    o=loc,
                    s='float $hfv = `camera -q -hfv ' + camera + '`;\n' +
                    'float $vfv = `camera -q -vfv ' + camera + '`;\n' +
                    'cam_x_value = (((' + dmn + '.otx/(-' + dmn +
                    '.otz))/tand($hfv/2))/2.0+.5)*1920;\n' +
                    'float $y_value = (((' + dmn + '.oty/(-' + dmn +
                    '.otz))/tand($vfv/2))/2.0+.5);\n' +
                    'cam_y_value = (-($y_value*1440)+1440)-180;')

    return loc
예제 #9
0
def makeWingExp():
    #Defining Variables
    axis = cmds.radioButtonGrp('whichAx', q=True, select=True)
    neg = cmds.radioButtonGrp('neg', q=True, select=True)
    speed = cmds.floatSliderGrp('speed', q=True, v=True)
    arc = cmds.floatSliderGrp('arc', q=True, v=True)

    if (axis == 1):
        chosenAxis = "rotateX"
    elif (axis == 2):
        chosenAxis = "rotateY"
    elif (axis == 3):
        chosenAxis = "rotateZ"

    if (neg == 1):
        negated = 1
    elif (neg == 2):
        negated = -1

    #Defining Selection
    selection = cmds.ls(sl=True)

    #Creating Expression
    expContent = (selection[0] + "." + str(chosenAxis) + " = ( " +
                  str(negated) + "* sin (time * " + str(speed) + ") * " +
                  str(arc) + ");")

    cmds.expression(string=expContent)
예제 #10
0
 def customizeCamera(self, camera):
     cmds.lookThru(camera)
     cmds.addAttr(
         camera,
         ln="Overlay",
         at="enum",
         en=
         "No Overlay:Grid:SpiralTopRight:SpiralTopLeft:SpiralBottomRight:SpiralBottomLeft"
     )
     cmds.addAttr(camera, ln="Overlay_Value", at="long")
     cmds.setAttr(camera + '.Overlay', e=True, keyable=True)
     cmds.setAttr(camera + '.Overlay_Value', e=True, keyable=True)
     cmds.expression(
         s='int $a=%s.Overlay;\r\n' % camera +
         '%s.Overlay_Value=$a;' % camera + 'switch($a) { \r\n' +
         '  case 0: \r\n' +
         '    python("camera_overlays.Overlay_Function().noOverlay()"); \r\n'
         + '    break;\r\n' + '  case 1: \r\n' +
         '    python("camera_overlays.Overlay_Function().toggleThirdsGrid()"); \r\n'
         + '    break;\r\n' + '  case 2: \r\n' +
         '    python("camera_overlays.Overlay_Function().toggleGoldenSprialTopRight()"); \r\n'
         + '    break;\r\n' + '  case 3: \r\n' +
         '    python("camera_overlays.Overlay_Function().toggleGoldenSprialTopLeft()"); \r\n'
         + '    break;\r\n' + '  case 4: \r\n' +
         '    python("camera_overlays.Overlay_Function().toggleGoldenSprialBottomRight()"); \r\n'
         + '    break;\r\n' + '  case 5: \r\n' +
         '    python("camera_overlays.Overlay_Function().toggleGoldenSprialBottomLeft()"); \r\n'
         + '}select %s;\r' % camera,
         ae=False,
         o="renderCam")
def stabilizer ():
	global _camera_
	_point = cmds.ls (selection = True)
	
	if cmds.objExists ('stabilizator_expression') == False and len(_point) > 0:
		_camera_	= Camera()
		_point		= _point[0]

		if (cmds.nodeType (_point) == 'mesh' or cmds.nodeType (_point) == 'transform') and _camera_.transform != 'empty':
			_expression	=	r'''
$pos=`python "fmmu.get_normalized_screen_position(\"'''	+	_point	+	r'''\")"`;
setAttr "'''	+	_camera_.shape	+	r'''.horizontalFilmOffset" $pos[2];
setAttr "'''	+	_camera_.shape	+	r'''.verticalFilmOffset" $pos[3];'''

			print "=================================="
			print _expression
			cmds.expression		(name = 'stabilizator_expression', string = _expression)
			cmds.frameLayout	('adjustCam_frml', edit = True, visible = True)
			cmds.symbolButton	('button_stabilizer', edit = True, image = 'ford_matchMoveUtilities__deStabilize.xpm', annotation = 'deStabilizer')
			cmds.floatField		('field_overscan', edit = True, value = _camera_.overscan)

	else:
		if cmds.objExists ('stabilizator_expression') == True:
			cmds.delete ('stabilizator_expression')
		
		cmds.symbolButton	('button_stabilizer', edit = True, image = 'ford_matchMoveUtilities__stabilize.xpm', annotation = 'deStabilizer')
		cmds.frameLayout	('adjustCam_frml', edit = True, collapse = True, visible = False)
		
		try:
			_camera_.reset_camera()
		except:
			pass
예제 #12
0
파일: herds.py 프로젝트: roboneill/herds
	def create(self, objnum, shape="cone"):
		if shape == "cone":
			node = cmds.cone(ch=False, n='herdmemb')
		else:
			node = cmds.duplicate(shape, ic=True, n='herdmemb')

		cmds.addAttr(node, sn='fad', ln='frameAdjust', dv=0, k=True)
	
		values = herds().values()
		
		cmds.expression(s=("$herdvar = " + str(random.random() - 0.5) + " * " + self.leader + ".rnds + " + str(objnum) + ";\n"
						+ "$randfac = " + self.leader + ".stry;\n"
						+ "$foc = " + self.leader + ".lf;\n"
						+ "if( $foc != 0 ) {\n"
						+ "$randfac *= min( 1.0,abs($herdvar)*(1-$foc)/($foc*"+ str(values["population"]) +") );}\n"
						+ "$herdvar = $herdvar * -" + self.leader + ".frameOffset + frame +" + node[0] + ".frameAdjust;\n"
						+ "$offset = " + str(random.random() - 0.45) + " * $randfac;\n"
						+ node[0] + ".tx = $offset + `getAttr -time $herdvar " + self.leader + ".tx`;\n" 
						+ "$offset = " + str(random.random() - 0.45) + " * $randfac;\n"
						+ node[0] + ".ty = $offset + `getAttr -time $herdvar " + self.leader + ".ty`;\n" 
						+ "$offset = " + str(random.random() - 0.45) + " * $randfac;\n"
						+ node[0] + ".tz = $offset + `getAttr -time $herdvar " + self.leader + ".tz`;\n"
						), n=(node[0] + "_herd_exp"))
		# Turns off the checker for finding cycles - throws up lots of warnings without it.
		cmds.cycleCheck(e=True, all=False)
		
		self.node = node[0]
		self.point()
		
		return node
예제 #13
0
def turntable():
    """
    Main function. Creates turntable. Requires a list of selected objects.
    :return: None
    """
    objs = cmds.ls(selection=True)
    meshes = checkSelection(objs)
    if not meshes:
        cmds.error('Please select a mesh object')
    pivlist = getSelectionPivot(meshes)
    turnCam = createCamera()
    centroid = findCentroid(pivlist)

    # change camera pivot to centroid
    cmds.xform(turnCam[0], ws=True, piv=centroid)

    # animate camera. rotate around y axis.
    firstFrame = str(cmds.playbackOptions(q=True, minTime=True))
    lastFrame = str(cmds.playbackOptions(q=True, maxTime=True))
    cmds.expression(name='TurnTableExpression',
                    string='{0}.rotateY=360*(frame-{1})/{2}-{1};'.format(
                        turnCam[0], firstFrame, lastFrame))

    # create a 3 point light rig.
    keyLight = createLight('areaLight', 'key', centroid)
    fillLight = createLight('areaLight', 'fill', centroid)
    rimLight = createLight('areaLight', 'rim', centroid)
    cmds.lookThru(turnCam[0])
    def setupScapula(self, jointScapula, colourTU, leftRight,
                     shoulderOffsetCtrl, *args):
        jntScap = jointScapula[0]
        childScap = mc.listRelatives(jntScap, c=True, type="joint")[0]
        scapLength = mc.getAttr("{0}.ty".format(childScap))
        scapulaOffsetCtrl = CRU.createCTRLs(jntScap,
                                            size=6,
                                            ornt=True,
                                            colour=colourTU,
                                            orientVal=(1, 0, 0),
                                            sectionsTU=8)

        mc.select(scapulaOffsetCtrl[1] + ".cv[:]")
        mc.move(-scapLength * 0.5, scapLength * 0.5, 0, r=True, ls=True)
        autoAttrName = "autoScapula"
        mc.addAttr(scapulaOffsetCtrl,
                   longName=autoAttrName,
                   at="float",
                   k=True,
                   min=0,
                   max=1,
                   dv=0.5)
        autoName = scapulaOffsetCtrl[2]
        xprNameScap = "expr_" + leftRight + "scapula"

        # AUTO_CTRL_l_scapula.rotateX = -1*CTRL_l_shoulder.rotateZ * CTRL_l_scapula.autoScapula;
        exprStringScap = "{0}.rotateX = -1*{1}.rotateZ * {2}.{3};\n".format(
            autoName, shoulderOffsetCtrl[1], scapulaOffsetCtrl[1],
            autoAttrName)

        mc.expression(s=exprStringScap, n=xprNameScap)
        mc.parent(scapulaOffsetCtrl[0], shoulderOffsetCtrl[1])

        return scapulaOffsetCtrl
예제 #15
0
 def execute(self):
     if not Maya.load_plugin("redshift4maya.mll"):
         self.append_error("Load redshift4maya.mll failed.")
         return
     if not self.files:
         self.append_error("No rs files found")
         return
     file_num = len(self.files)
     if file_num == 1:
         file_name = self.files[0]
     else:
         frame_padding = self.frame_padding(self.files[0], "rs")
         file_name = re.sub("\d+\.rs$", "%s.rs" % ("#" * frame_padding),
                            self.files[0])
     node = Maya.import_rs(file_name)
     if file_num > 1:
         mc.setAttr("%s.useFrameExtension" % node, True)
         exp = mc.createNode("expression", name="expression")
         mc.connectAttr("%s.out[0]" % exp, "%s.frameExtension" % node, f=1)
         mc.expression(exp,
                       e=1,
                       s="{0}.frameExtension=(frame-1)%{1}+1".format(
                           node, file_num),
                       ae=1,
                       uc="all")
    def setupClavicle(self, jointClavicle, colourTU, leftRight,
                      shoulderOffsetCtrl, jntArmArray, *args):
        jntClav = jointClavicle[0]
        childClavicle = mc.listRelatives(jntClav, c=True, type="joint")[0]
        clavLength = mc.getAttr("{0}.ty".format(childClavicle))
        clavicleOffsetCtrl = CRU.createCTRLs(jntClav,
                                             size=6,
                                             ornt=True,
                                             colour=colourTU,
                                             orientVal=(0, 0, 1),
                                             sectionsTU=6)
        mc.select(clavicleOffsetCtrl[1] + ".cv[:]")
        mc.move(clavLength * 0.5, clavLength * 0.5, 0, r=True, ls=True)
        autoAttrName = "autoClavicle"
        mc.addAttr(clavicleOffsetCtrl,
                   longName=autoAttrName,
                   at="float",
                   k=True,
                   min=0,
                   max=1,
                   dv=0.05)
        autoName = clavicleOffsetCtrl[2]
        xprNameClav = "expr_" + leftRight + "clavicle"

        # AUTO_CTRL_l_clavicle.rotateX = JNT_l_upperArm.rotateX * CTRL_l_clavicle.autoClavicle;
        exprStringClav = self.tgpAutoClavicleRotate(autoName, jntArmArray[0],
                                                    clavicleOffsetCtrl[1],
                                                    autoAttrName)

        mc.expression(s=exprStringClav, n=xprNameClav)
        mc.parent(clavicleOffsetCtrl[0], shoulderOffsetCtrl[1])

        return clavicleOffsetCtrl
def stabilizer (task):
	camera	= Camera()
	point	= cmds.ls (selection = True)

	if task == 'end':
		# turn off stab
		expression		= str (cmds.expression ('stabilizator_expression', string = True, query = True))
		camera.shape	= expression[2:expression.find('#')]
		cmds.delete ('stabilizator_expression')
		camera.reset_camera ()
		cmds.button ('button_stabilizer',
					edit				= True,
					label				= 'stabilize',
					backgroundColor		= (0, 0.5, 0),
					command				= 'fstab.stabilizer("start")')

	else:
		# start stab
		if cmds.objExists ('stabilizator_expression'):
			# stabilizator exists
			expression		= str (cmds.expression ('stabilizator_expression', string = True, query = True))
			camera.shape	= expression[2:expression.find('#')]
			cmds.delete ('stabilizator_expression')
			cmds.select (camera.shape, replace = True)
			cmds.warning (('>>> STAB WAS TURNED ON. CHECK: ' + camera.shape + ' <<< FOR NONZERO OFFSET VALUES ::..'))
		
		else:
			if cmds.nodeType (point) != 'mesh' and cmds.nodeType (point) != 'transform' and len (point) == 0:
				# wrong selection
				cmds.warning ('..:: SELECT SOMETHING TO STABILIZE ::..')
			else:
				point = point[0]
				
				if point != camera.transform and point != camera.shape and camera.transform != 'empty':
					# stabilize
					cmds.setAttr( camera.shape + '.displayResolution', 0)
					cmds.setAttr( camera.shape + '.displayFilmGate', 0)
				
					expression = '//%s#' % camera.shape
					expression += '\npython "import maya.cmds as cmds";'
					expression += '\npython "fov_h = cmds.camera (\'%s\', query = True, horizontalFieldOfView = True)";' % camera.shape
					expression += '\npython "fov_v = cmds.camera (\'%s\', query = True, verticalFieldOfView = True)";' % camera.shape
					expression += '\npython "aperture_h = cmds.camera (\'%s\', query = True, horizontalFilmAperture = True)";' % camera.shape
					expression += '\npython "aperture_v = cmds.camera (\'%s\', query = True, verticalFilmAperture = True)";' % camera.shape
					expression += '\n$pos=`python "fstab.get_normalized_screen_position(\'%s\',\'%s\',fov_h, fov_v,aperture_h,aperture_v)"`;' % (point, camera.transform)
					expression += '\nsetAttr "%s.horizontalFilmOffset" ($pos[2]);' % camera.shape
					expression += '\nsetAttr "%s.verticalFilmOffset" ($pos[3]);' % camera.shape

					# create expression
					cmds.expression		(name = 'stabilizator_expression', string = expression)
		
					# update GUI
					cmds.button			('button_stabilizer',
										edit			= True,
										label			="deStabilize",
										backgroundColor	= (1, 0, 0),
										command			= 'fstab.stabilizer("end")')
					
				else:
					cmds.warning ('..:: CLICK IN THE PANE WITH THE CAMERA ::..')
예제 #18
0
def createSpeedAttribute(*args):
    '''This will create an attribute on any object which shows its speed in kmh at current frame'''
    sel = cmds.ls(selection=True)
    if len(sel) != 1:
        cmds.warning('One object must be selected')
    else:
        sel = sel[0]
        cmds.addAttr(sel,
                     ln='speed',
                     nn='Speed (kmh)',
                     at='double',
                     dv=0,
                     h=False,
                     k=True)
        cmds.expression(
            s="float $lastPosX = `getAttr -t (frame-1) " + sel +
            ".tx`;\nfloat $lastPosY = `getAttr -t (frame-1) " + sel +
            ".ty`;\nfloat $lastPosZ = `getAttr -t (frame-1) " + sel +
            ".tz`;\n\nfloat $tempSpeed = abs (mag (<<" + sel + ".translateX," +
            sel + ".translateY," + sel +
            ".translateZ>>)- mag (<<$lastPosX,$lastPosY,$lastPosZ>>) );\n\n" +
            sel + ".speed = ((($tempSpeed/100)*24)*3.6)",
            ae=1,
            uc='all')
        cmds.select(sel, r=True)
예제 #19
0
	def __init__(self, curve, objects, pointsCount, useTips = False, keepConnected = True, tangent = False,rand = False, groupit = False, animated = False  ):
		"""creates objects allong curve,
		curve: Curve Class object that handles the curve
		objects: Array of one o more transforms objects to position allong curve
		pointsCount: Amount of points in the curve
		useTips: is to position objects in the curve
		keepConnected: Keep pointOnCurveInfo connected between transform and curve
		tangent: Manage rotation on objects also
		rand: Place the objects in random order
		animated: Add speed attribute to move objects along curve"""
		self._nodes = []
		self._curve    = curve
		if useTips:
			val = -1
		else:
			val = 1
		startParam = 1.0 / ( pointsCount + val )
		param      = 0
		objsIter = it.bicycle( objects )
		grp = mn.Node( curve.name + '_grp' )
		if groupit:
			grp = mn.Node( mc.group( n = grp.name, em = True ) )
			if animated:
				grp.a.laps.add( k = True )
		with undo.Undo():
			for p in range( pointsCount ):
				#place transform in param point
				if not useTips:
					param += startParam
				if rand:
					baseobj = random.choice( objects )
				else:
					baseobj = objsIter.next()
				obj = baseobj.duplicate()
				self._nodes.append( obj )
				if groupit:
					obj.parent = grp
				pcurveNode = mn.Node( mc.pathAnimation( obj.name, su=0.5,  c=curve.name, fm = True, follow=tangent, followAxis = 'z', upAxis = 'y', worldUpType = 'object', worldUpObject = curve.parent.name ) )
				animCurve = pcurveNode.a.uValue.input.node
				animCurve.delete()
				if keepConnected:
					obj.a.parameter.add( k = True )
					obj.a.parameter.v = param
					obj.a.parameter.min = 0
					obj.a.parameter.max = 1
					obj.a.parameter >> pcurveNode.a.uValue
				else:
					if param > 1.0:
						param = 1
					pcurveNode.a.uValue.v = param
					t = obj.a.t.v
					r = obj.a.r.v
					pcurveNode.delete()
					obj.a.t.v = t[0]
					obj.a.r.v = r[0]
				if useTips:
					param += startParam
				if animated:
					cmd = obj.a.parameter.fullname + ' = ( abs( ' + str( obj.a.parameter.v ) + ' + ' + grp.a.laps.fullname + ' ) ) % 1;'
					mc.expression( s=cmd )
예제 #20
0
def mirror_locators(**kwargs):
    file_name = kwargs.setdefault('filename')
    unmirror = kwargs.setdefault('unmirror', False)
    file_list = ['up_eye', 'low_eye', 'cheek', 'up_mouth', 'low_mouth']
    if unmirror is False:
        if file_name == 'all':
            for i in range(0, len(file_list)):
                file_path = get_file_path('expressions/%s' % file_list[i])
                with open(file_path) as myfile:
                    expressionData = myfile.read()
                mc.expression(string=expressionData, name="%s_Expression" % file_list[i], ae=1, uc='all')
            py.headsUpMessage('Mirroring for all enabled. Must unmirror to reset locations')
        else:
            file_path = get_file_path('expressions/%s' % file_name)
            with open(file_path) as myfile:
                expressionData = myfile.read()
            mc.expression(string=expressionData, name="%s_Expression" % file_name, ae=1, uc='all')
            py.headsUpMessage('Mirroring for %s enabled. Must unmirror to reset locations' % file_name)
    else:
        for i in range(0, len(file_list)):
            try:
                mc.delete('%s_Expression' % file_list[i])
            except:
                pass
        py.headsUpMessage('Mirroring disabled')
예제 #21
0
def createPolyImagePlane(camera, cameraShape, imagePlane):
    # Create Nodes
    implane, polyPlane = cmds.polyPlane(n="projectionCam_PLY",
                                        sx=1,
                                        sy=1,
                                        cuv=2,
                                        ch=1,
                                        ax=(0, 1, 0),
                                        w=1,
                                        h=1)
    planeShape = str(cmds.listRelatives(implane, c=True, type="mesh")[0])
    cmds.parent(implane, camera)
    # Add expression
    exp = ''
    exp += 'float $f = %s.focalLength;\n' % cameraShape
    exp += 'float $fbw = %s.horizontalFilmAperture;\n' % cameraShape
    exp += 'float $fbh = %s.verticalFilmAperture;\n' % cameraShape
    exp += 'float $fov = rad_to_deg(2 * atan( ($fbw*25.4) / (2 * $f) ));\n'
    exp += 'float $planeScale = 2*(%s.depth)*(tand($fov/2.0));\n\n' % imagePlane
    exp += '%s.width = 1.0;\n' % polyPlane
    exp += '%s.height = $fbh/$fbw;\n\n' % polyPlane
    exp += 'translateX = $planeScale*0.5*((%s.offsetX/2.54)/(($fbw/2.54)*0.5));\n' % imagePlane
    exp += 'translateY = $planeScale*0.5*((%s.offsetY/2.54)/(($fbw/2.54)*0.5));\n' % imagePlane
    exp += 'translateZ = -1*%s.depth;\n' % imagePlane
    exp += 'rotateX = 90.0;\n'
    exp += 'rotateY = rotateZ = 0.0;\n\n'
    exp += 'scaleX = scaleY = scaleZ = $planeScale;\n\n'
    cmds.expression(string=exp,
                    object=implane,
                    alwaysEvaluate=True,
                    unitConversion='all')
    return (implane, planeShape, polyPlane)
예제 #22
0
def MakeWheel(radius=3.6):  # Function returns group name for a wheel
    myListOfRotValues = range(0, 360, 20)
    wheel = []
    x = 0
    for curCyl in myListOfRotValues:
        curSpoke = mc.polyCylinder(r=0.1, h=radius)
        wheel.append(curSpoke[0])
        mc.move(0, radius / 2, 0)
        mc.move(0, 0, 0, curSpoke[0] + ".scalePivot",
                curSpoke[0] + ".rotatePivot")
        mc.rotate(20 * x, 0, 0)
        x += 1

    wheelCenter = mc.polyCylinder(ax=(1, 0, 0))
    wheel.append(wheelCenter[0])
    mc.scale(0.22, 0.6, 0.6)

    wheelEdge = mc.polyTorus(r=radius, sr=0.3, sx=40, sy=5, ax=(1, 0, 0))
    mc.scale(0.537, 1, 1)
    wheel.append(wheelEdge[0])

    finalWheel = mc.group(wheel)

    if trainSpeed > 0:
        circumference = 2 * 3.14 * radius
        wheelRotationTime = (circumference / trainSpeed)
        mc.expression(s="rotateX = time * (360 / " + str(wheelRotationTime) +
                      ");",
                      o=finalWheel)

    return finalWheel
예제 #23
0
def runPreset():
	cmds.select(clear=True)
	cmds.promptDialog(message='Nome do sistema MASH:')
	mashName = cmds.promptDialog(query=True, text=True)
	if not mashName:
		mashName = '#'
	else:
		mashName = '_' + mashName
	############################################################################################
	steps = [	'Selecione as instancias | n >= 2 (arraste com o botao do meio)',
				'Selecione a superficie  | n = 1  (arraste com o botao do meio)']
	accepts = [['mesh'], ['mesh']]
	############################################################################################
	fx.DropWindow.getDrop(	steps,
							lambda data: smartPreset.send(data),
							accepts=accepts)
	node = yield
	nodes = node.split('\n')
	############################################################################################
	cmds.promptDialog(message='Numero de pontos:')
	pointCount = cmds.promptDialog(query=True, text=True)
	try:
		pointCount =  int(pointCount)
	except:
		pointCount = 10
	
	mash = mapi.Network()
	mash.createNetwork(name='MASH' + mashName, geometry='Instancer')

	node = yield
	node = node.split('\n')[0]

	mash.meshDistribute(node)
	############################################################################################
	distNodeName = mash.waiter + '_Distribute'
	cmds.setAttr(distNodeName + '.pointCount', pointCount)

	idNodeName = mash.waiter + '_ID'
	cmds.setAttr(idNodeName + '.idtype', 2)
	count = cmds.getAttr(idNodeName + '.numObjects')

	pyNode = mash.addNode('MASH_Python')
	cmds.addAttr(pyNode.name, longName='countID', attributeType='long', defaultValue=count)
	expr = '{0}.countID = {1}.numObjects'.format(pyNode.name, idNodeName)
	cmds.expression(s=expr)
	cmds.addAttr(pyNode.name, longName='seed', attributeType='long', defaultValue=1234)
	scriptID = ''.join(['p[{0}] = 1  # {1} prob.\n'.format(i, e) for i, e in enumerate(nodes)])
	cmds.setAttr(pyNode.name + '.pyScript', SCRIPT.format(scriptID), type='string')

	randNode = mash.addNode('MASH_Random')
	cmds.setAttr(randNode.name + '.positionX', 0)
	cmds.setAttr(randNode.name + '.positionY', 0)
	cmds.setAttr(randNode.name + '.positionZ', 0)
	cmds.setAttr(randNode.name + '.rotationY', 180)
	cmds.setAttr(randNode.name + '.scaleX', 1)
	cmds.setAttr(randNode.name + '.uniformRandom', 1)

	strengthNode = mash.addNode('MASH_Strength')

	yield
예제 #24
0
def main():
    if mc.objExists("*horizonLine*"):
        mc.delete("*horizonLine*")  # Delete existing "horizonLine"
        return

    active3dViewCamShape, active3dViewCamTrans = getActive3dViewCam()

    horizonLineTrans = mc.circle(name='horizonLine',
                                 radius=2,
                                 normal=(0, 1, 0),
                                 sections=32)[0]
    horizonLineShape = mc.listRelatives(horizonLineTrans,
                                        shapes=True,
                                        fullPath=True)[0]

    mc.expression(s="""
                    {0}.sx = {1}.nearClipPlane;
                    {0}.sy = {1}.nearClipPlane;
                    {0}.sz = {1}.nearClipPlane;
                    """.format(horizonLineTrans, active3dViewCamShape),
                  object=horizonLineTrans)

    mc.setAttr(horizonLineShape + '.overrideEnabled', 1)
    mc.setAttr(horizonLineShape + '.overrideColor', 14)

    mc.pointConstraint(active3dViewCamTrans,
                       horizonLineTrans,
                       maintainOffset=False)

    mc.select(clear=True)
예제 #25
0
def eyeRig(scaler): #try 4
    target = mc.ls(sl=1)
    mc.delete(e=True)
    for i in range(0,len(target)):
        if(i<len(target)-1):
            mc.expression(s=target[i]+".rotateX = " + target[len(target)-1] + ".translateY * -1 * " + str(scaler))
            mc.expression(s=target[i]+".rotateY = " + target[len(target)-1] + ".translateX * " + str(scaler))
예제 #26
0
 def customizeCamera(self, camera):
     cmds.lookThru(camera)
     cmds.addAttr(camera, ln="Overlay", at="enum", en="No Overlay:Grid:SpiralTopRight:SpiralTopLeft:SpiralBottomRight:SpiralBottomLeft")
     cmds.addAttr(camera, ln="Overlay_Value", at="long")
     cmds.setAttr(camera + '.Overlay', e=True, keyable=True)
     cmds.setAttr(camera + '.Overlay_Value', e=True, keyable=True)
     cmds.expression(s='int $a=%s.Overlay;\r\n' % camera +
                       '%s.Overlay_Value=$a;' % camera+
                       'switch($a) { \r\n' +
                       '  case 0: \r\n' +
                       '    python("camera_overlays.Overlay_Function().noOverlay()"); \r\n' +
                       '    break;\r\n' +
                       '  case 1: \r\n' +
                       '    python("camera_overlays.Overlay_Function().toggleThirdsGrid()"); \r\n' +
                       '    break;\r\n' +
                       '  case 2: \r\n' +
                       '    python("camera_overlays.Overlay_Function().toggleGoldenSprialTopRight()"); \r\n' +
                       '    break;\r\n' +
                       '  case 3: \r\n' +
                       '    python("camera_overlays.Overlay_Function().toggleGoldenSprialTopLeft()"); \r\n' +
                       '    break;\r\n' +
                       '  case 4: \r\n' +
                       '    python("camera_overlays.Overlay_Function().toggleGoldenSprialBottomRight()"); \r\n' +
                       '    break;\r\n' +
                       '  case 5: \r\n' +
                       '    python("camera_overlays.Overlay_Function().toggleGoldenSprialBottomLeft()"); \r\n' +
                       '}select %s;\r' % camera, ae=False, o="renderCam")
def _update_flipbook_node(new_page, current_frame):
    """ Updates the flipbook node with a new page in the enumerator
    and sets the key for that frame.

    :param new_page:
    :type new_page:
    :returns: None
    """
    # ...:
    cmds.expression(object=new_page,
            name="%s_visbility_EXP" % (new_page),
            string="int $page = %d;\n"
            "int $current_keyed_frame = flipbook_LOC.pagesToDisplay;\n"
            "%s.visibility = ($page==$current_keyed_frame)||(visibilityOverride);"
            % (current_frame, new_page),
            alwaysEvaluate=True)

    # We will also be adding another attribute with just integer values.
    # This will be set here at this point as well.
    cmds.setKeyframe("flipbook_LOC.pagesToDisplay",
                     value=current_frame,
                     time=current_frame,
                     outTangentType="step")

    # Return:
    return
예제 #28
0
def createExpression(att, minVal, maxVal, speed):
	"""
	create a expresion for wave animation
	- animate objects attribute using a wave Function
	- create a custom speed atribute
	- Calculate values for the wave fuction:
		speed      = wave to strech or shrink alnog the horizantal
		multiplier = overal range (min/max, or top/down wave)
		offset     =  min/max values are where they should be.
		we move the 0 position of the wave to be
		midway between our minVal and maxVal
	- Create the expression
	- run script when item is seleced
	
	"""
	# get selected object
	objs = cmds.ls(selection=True)
	obj = objs[0]

	# create Attr: Speed
	cmds.addAttr(obj, longName="speed", shortName="speed", min=0, keyable=True)
	
	amplitude = (maxVal - minVal)/2.0 # multiplier
	offset = minVal + amplitude # offset
	
	# set expresion items
	baseString = "{0}.{1} = ".format(obj, att) # object.attribute as string
	sineClause = '(sin(time * '+ obj + '.speed)' # sin Function as a string
	valueClause = ' * ' + str(amplitude) + ' + ' + str(offset) + ')'
	# set expression
	expressionString = baseString + sineClause + valueClause
	cmds.expression(string=expressionString)
예제 #29
0
def editMainExpression(objectName="", splashDisc="", oceanShader="", objectNameEmitter="", wakeEmitter="", splashDiscEmitter=""):
    """
    editing the main expression for the scene
    @param splashDiscParticle: Name of SplashDiscParticle
    @type splashDiscParticle: String
    --------------------------------------------
    @return: 0-ExpressionText
    """
    
    oldMainExoression = cmds.expression("ocean_MainExpression",query=True, string=True)
    
    startExpression = "\n////////////////////////////// Start %s Expression //////////////////////////////\n"%objectName
    
    newExp = ""
    newExp += "float $%s_particleSprayRate = 3000;\n"%objectName
    newExp += "float $%s_particleBubblesRate = 100;\n" %objectName
    newExp += "float $%s_fluidDisplacement = 6.0;\n" %objectName
    newExp += "float $%s_fluidFoam = 2.0;\n" %objectName
    newExp += "float $%s_u = .I[0];\n" %objectName
    newExp += "float $%s_v = .I[1];\n" %objectName
    newExp += "float $%s_disp[] = `colorAtPoint -u $%s_u -v $%s_v %s`;\n" %(objectName,objectName,objectName,oceanShader)
    newExp += "float $%s_lastY = `getAttr -time (frame - 2) %s.translateY`;\n" %(objectName,objectName)
    newExp += "float $%s_curY = %s.translateY;\n" %(objectName,objectName)
    newExp += "float $%s_ydiff = $%s_lastY - $%s_curY;\n" %(objectName,objectName,objectName)
    
    newExp += "if( $%s_curY < 0.5 ){\n\t"%objectName
    newExp += "%s.rate = $%s_particleBubblesRate;"%(objectNameEmitter,objectName)
    newExp += "\n} else {\n\t"
    newExp += "%s.rate = 0;\n}\n"%objectNameEmitter
    newExp += "if( $%s_ydiff < 0 ){\n\t"%objectName
    newExp += "$%s_ydiff = -$%s_ydiff;"%(objectName,objectName)
    newExp += "\n}\n"
    newExp += "if( $%s_curY > -1 && $%s_curY < 0.6 ){\n\t"%(objectName,objectName)
    newExp += "%s.fluidDensityEmission = $%s_fluidDisplacement;\n\t"%(wakeEmitter,objectName)
    newExp += "%s.fluidHeatEmission = $%s_fluidFoam;"%(wakeEmitter,objectName)
    newExp += "\n} else {\n\t"
    newExp += "%s.fluidDensityEmission = 0;\n\t"%wakeEmitter
    newExp += "%s.fluidHeatEmission = 0;"%wakeEmitter
    newExp += "\n}\n"
    newExp += "if( $%s_curY > -1 && $%s_curY < 0.5 && $%s_ydiff > 0.05 ){\n\t"%(objectName,objectName,objectName)
    newExp += "%s.rate = $%s_particleSprayRate * $%s_ydiff;\n\t"%(splashDiscEmitter,objectName,objectName)
    newExp += "float $%s_speed = $%s_ydiff * 10;\n\t"%(objectName,objectName)
    newExp += "if( $%s_speed > 10 ){\n\t\t"%objectName
    newExp += "$%s_speed = 10;"%objectName
    newExp += "\n\t}\n\t"
    newExp += "%s.speed = $%s_speed;"%(splashDiscEmitter,objectName)
    newExp += "\n} else {\n\t"
    newExp += "%s.rate = 0;"%splashDiscEmitter
    newExp += "\n}\n"
    newExp += "%s.translateY = $%s_disp[0];\n"%(splashDisc,objectName)
    newExp += "float $%s_dummy = %s.displacement;\n"%(objectName,oceanShader)

    endExpression = "////////////////////////////// End %s Expression //////////////////////////////\n\n"%objectName

    totalExp = oldMainExoression+startExpression+newExp+endExpression
    
    cmds.expression ("ocean_MainExpression",string=totalExp ,edit=True, alwaysEvaluate=1, unitConversion="all")
    
    return totalExp
예제 #30
0
    def createObjs(self):
        #Materials
        matCols = [[0, 1, 1], [1, 1, 0], [0, 1, 0], [1, 0, 0], [0, 0, 1],
                   [1, 0.5, 0], [1, 0, 1]]
        for num in range(7):
            name = 'mino_' + str(num) + '_mat'
            if not cmds.objExists(name + 'SG'):
                cmds.sets(n=name + 'SG',
                          renderable=1,
                          noSurfaceShader=1,
                          empty=1)
            if not cmds.objExists(name):
                cmds.shadingNode('lambert', asShader=1, n=name)
                cmds.setAttr(name + '.color',
                             matCols[num][0],
                             matCols[num][1],
                             matCols[num][2],
                             type='double3')
                cmds.connectAttr(name + '.outColor',
                                 name + 'SG.surfaceShader',
                                 f=1)

        #Anim for force evaluation
        if (not cmds.objExists('dummyAnim')):
            cmds.createNode('animCurveTU', name='dummyAnim')
            cmds.setAttr('dummyAnim.postInfinity', 3)
            cmds.setKeyframe('dummyAnim', t=0, v=1)
            cmds.setKeyframe('dummyAnim', t=1, v=1.0001)

        #borad
        for x in range(w):
            for y in range(h):
                coreName = '_' + str(x) + '_' + str(y)
                for c in range(7):
                    name = 'c' + str(c) + coreName
                    sgName = 'mino_' + str(c) + '_matSG'
                    if not cmds.objExists(name):
                        cmds.polyCube(n=name, w=0.95, d=0.95, h=0.95)
                        cmds.setAttr('.t', x, y, 0)
                        cmds.sets(name, e=1, fe=sgName)
                    cmds.connectAttr('dummyAnim.o', name + '.sz', f=1)

        #controllers
        if not cmds.objExists('b_left'):
            cmds.group(em=1, n='b_left')
            cmds.group(n='b_up')
            cmds.group(em=1, n='b_down')
            cmds.group(n='neutral', parent='b_up')
            cmds.group(em=1, n='b_right', parent='b_up')

        #expression
        if not cmds.objExists('input_exp'):
            cmds.expression(
                n='input_exp',
                s="neutral.translateX=0;\nstring $sels[]=`ls -sl`;\n" +
                "python (\"t.tetObj.update('\"+$sels[0]+\"')\");\nselect -r neutral;",
                o='right',
                ae=1,
                uc='all')
예제 #31
0
def connectAttrs(newObj,oldObj):
    #r = str(0.7)
    for attr in attrs:
        #if attr=='translateX':
        #    #scale translateX
        #    cmds.expression(s = newObj+'.' +attr+ ' = ' + r + '*' + oldObj+'.' +attr)
        #else:
        cmds.expression(s = newObj+'.' +attr+ ' = ' + oldObj+'.' +attr)
def loop_selection(num_loops, step=1):
    """ Loop over selected pages num_loop times.

    With the pages selected in the maya scene, loop over the pages
    num_loop times with step amount of frames between each loop.
    And some...

    :param num_loops: The page to display.
    :param step: The number of frames between the loop.
    :type num_loops: int.
    :type step: int.
    :returns:  List.
    :raises: None.

    .. note::

       There is a Maya Expression declared in this function as a string.
       This could be removed to another file and use something like Jinja
       to work with it.
    """
    # If there are pages selected:
    pages = cmds.ls(selection=True)
    if pages:
        regex = re.compile(r"page_(\d{4})")
        page_vals = [int(regex.search(page).group(1)) for page in pages]
        inc_value = (page_vals[-1] + step) - page_vals[0]
        page_loop = [page_vals[i] + (j * inc_value) for j in xrange(num_loops) for i in xrange(len(page_vals))]

        #
        page_array = ""

        # Set the expression now:
        for index, page in enumerate(page_vals):
            page_name = "page_%04d" % (page)
            expr_name = "page_%04d_visbility_EXP" % (page)

            if cmds.objExists(expr_name):
                cmds.delete(expr_name)

            # Reads the expression from the ./templates folder and fills
            # in the values before setting the expression on the curves
            # for that given page:
            exp = open(os.path.join(TEMPLATE_DIR, 'flipbookexpression.mel'), 'r').read()
            exp = exp % {'values': ','.join(map(str, page_loop[index::len(page_vals)])),
                         'end_values': ','.join(map(str, page_loop[index + 1::len(page_vals)])),
                         'page': page,
                         'page_name': page_name}
            cmds.expression(object=page_name,
                            name=expr_name,
                            string=exp,
                            alwaysEvaluate=True)

    go_to_page(page_vals[-1] + 1)
    page_name = "page_%04d" % (page_vals[-1] + 1)
    set_empty_page()

    # Return the loop list:
    return page_loop
예제 #33
0
def mkCam(name=None, img_plane_imgs=None, *args, **kwds):
    camera_node = mkNode("%s_cam" % name, "camera", *args, **kwds)
    img_plane_node = mkNode("%s_imagePlane" % name, "imagePlane")
    img_plane_node = mc.listRelatives(img_plane_node,
                                      shapes=True,
                                      fullPath=True)[0]
    annotate_node = mc.annotate("%s_cam" % name,
                                text="tc=...",
                                point=(0, -3, -10))
    annotate_node = mc.rename(
        mc.listRelatives(annotate_node, parent=True, fullPath=True),
        "%s_timecode" % name)

    if img_plane_imgs:
        if ROOT_DIR is not None:
            img_plane_imgs = os.path.join(ROOT_DIR, img_plane_imgs)
        mc.setAttr("%s.imageName" % img_plane_node,
                   img_plane_imgs,
                   type="string")
    mc.connectAttr("%s.message" % img_plane_node,
                   "%s.imagePlane[0]" % camera_node)
    # you'd think that this was the default, to actually use frameOffset, but nooooooo....
    mc.expression(s="%s.frameExtension=frame+%s.frameOffset" %
                  (img_plane_node, img_plane_node))

    mc.setAttr("%s.rotateOrder" % camera_node, 3)
    mc.setAttr("%s.focalLength" % camera_node, 28.0)
    mc.setAttr("%s.alphaGain" % img_plane_node, 0.85)
    mc.setAttr("%s.useFrameExtension" % img_plane_node, 1)

    mc.addAttr(camera_node, longName="tc_h", attributeType="byte")
    mc.addAttr(camera_node, longName="tc_m", attributeType="byte")
    mc.addAttr(camera_node, longName="tc_s", attributeType="byte")
    mc.addAttr(camera_node, longName="tc_f", attributeType="byte")
    mc.addAttr(camera_node, longName="msg_num", attributeType="long")

    mc.parent(annotate_node, img_plane_node, camera_node, relative=True)

    script = """string $tc = "";
string $h = $$NAME$$_cam.tc_h;
string $m = $$NAME$$_cam.tc_m;
string $s = $$NAME$$_cam.tc_s;
string $f = $$NAME$$_cam.tc_f;
if (size($h)==1) $h = "0" + $h;
if (size($m)==1) $m = "0" + $m;
if (size($s)==1) $s = "0" + $s;
if (size($f)==1) $f = "0" + $f;
$tc = "tc=" + $h + ":" + $m + ":" + $s + "." + $f;
setAttr $$NAME$$_timecodeShape.text -type \"string\" $tc;
""".replace("$$NAME$$", name)
    mc.expression(name="%s_tc_update" % annotate_node,
                  object=annotate_node,
                  string=script)

    mc.select(camera_node)

    return camera_node
예제 #34
0
	def _setDistance(self):
		''' 
		Creates expression
		Exp: moveVector = currentPosition - oldPosition
		'''
		exp = 'vector $move = <<%s.mvx,%s.mvy,%s.mvz>>;\n'%(self.node,self.node,self.node)
		exp += '%s.distance = mag($move);\n'%self.node

		cmds.expression(s=exp,n='%s_distExp'%self.ctrlName)	
예제 #35
0
    def CreateArnoldShader(self):
        if not mc.pluginInfo('mtoa.mll', q=True, l=True):
            mc.loadPlugin('mtoa.mll')

        planel = mc.ls(sl=True)
        if not planel:
            mc.confirmDialog(title=u"提示", message=u'请选择polyPlane!')
            return

        for p in planel:
            try:
                mc.setAttr('%s.aiOpaque' % p, 0)
                mc.setAttr('%s.aiSubdivType' % p, 1)
                mc.setAttr('%s.aiSubdivIterations' % p, 4)
            except:
                pass

        seaShader = mc.shadingNode('aiStandard', asShader=True, n='seaShader')
        #seaSG = mc.shadingNode('shadingEngine', asShader = True, n = 'seaSG')
        seaSG = mc.sets(renderable=True,
                        noSurfaceShader=True,
                        empty=True,
                        name='seaSG')
        mc.connectAttr('%s.outColor' % seaShader,
                       '%s.surfaceShader' % seaSG,
                       f=True)

        mc.select(planel)
        mc.sets(e=True, forceElement=seaSG)

        mc.setAttr('%s.color' % seaShader, 0, 0, 0, type='double3')
        mc.setAttr('%s.Kd' % seaShader, 0)
        mc.setAttr('%s.KsColor' % seaShader, 1, 1, 1, type='double3')
        mc.setAttr('%s.Ks' % seaShader, 0.5)
        mc.setAttr('%s.specularRoughness' % seaShader, 0)
        mc.setAttr('%s.specularFresnel' % seaShader, 1)
        mc.setAttr('%s.Ksn' % seaShader, 0.45)
        mc.setAttr('%s.Kt' % seaShader, 1)
        mc.setAttr('%s.IOR' % seaShader, 1.33)
        mc.setAttr('%s.opacity' % seaShader, 0.78, 0.78, 0.78, type='double3')

        seaDeform = mc.shadingNode('Ocean_Octvision',
                                   asShader=True,
                                   n='Ocean_Octvision')
        disShader = mc.shadingNode('displacementShader',
                                   asShader=True,
                                   n='OceanDisplacement')
        mc.connectAttr('%s.outColor' % seaDeform,
                       '%s.vectorDisplacement' % disShader,
                       f=True)
        mc.connectAttr('%s.displacement' % disShader,
                       '%s.displacementShader' % seaSG,
                       f=True)
        mc.expression(s='%s.time = 0.5*time;' % seaDeform,
                      o=seaDeform,
                      ae=True,
                      uc=all)
예제 #36
0
def addCorrectiveExpressionToMaster(master, blendshape_dummy, blendshape1, blendshape2):
	"""
	Add expression to turn on corrective expression when
	bs1 and bs2 are active.
	"""
	master_blendshape = getBlendshapesFromMaster(master)[0]
	expression_name = "exp_" + blendshape_dummy
	expression_string = master_blendshape+"."+blendshape_dummy + "=" + master_blendshape +"."+blendshape1 + " * " + master_blendshape+"."+blendshape2 + ";"
	expression(s=expression_string, n=expression_name)
예제 #37
0
def createAnimation():
	
	freq = .1
	offset = 0
	amp = 10

	cmds.expression(s = 'ctrl_0.rotateZ = sin((frame*.1)+0)*10')

	cmds.expression(s = 'ctrl_2.rotateZ = sin((frame*.1)+0)*10')
예제 #38
0
def swimExp(conObj, trgObjs, roAxis):
    for trg in trgObjs:
        cmds.expression(
            n='%s_swim_exp' % trg,
            ae=True,
            uc=all,
            s="// master controls\n $on_off = %s.on_off;\n $masSpeed = %s.speed;\n $masDelay = %s.delay;\n $masAmplitude = %s.amplitude;\n\n $speed = %s.%s_speed;\n $delay = %s.%s_delay;\n $amplitude = %s.%s_amplitude;\n\n %s_swim_grp.rotate%s = (sin((time * $speed * $masSpeed) + $delay + $masDelay) * $amplitude * $masAmplitude) * $on_off;"
            % (conObj, conObj, conObj, conObj, conObj, trg, conObj, trg,
               conObj, trg, trg, roAxis))
예제 #39
0
 def modifyBtnCmd(self, *args):
     nodeName = self.getNodeName()
     movieInputList = cmds.listConnections('%s_movieNode'%nodeName)
     expressions = [item for item in movieInputList if 'expression' in item]
     print expressions
     expressionString = cmds.expression(expressions[0], q = 1, s = 1)
     offsetFrame = cmds.intField(self.frameOffset, q = 1, v = 1)
     newString = '%s.frameExtension = frame - %s'%('%s_movieNode'%nodeName, str(offsetFrame))
     cmds.expression(expressions[0], e = 1, s = newString)
예제 #40
0
def generateSpider(input_namespace, startTime, endTime):
    '''
	this function attaches all curves together, without replacing the orignal curves, using it as a motion path
	for an animated spider. the animated spider is imported, and a simple expression links the U value of the motion
	path to a rotation attribute on the spider rig, controlling its walk cycle. there is also a custom attribute on
	the controller that appears with the spider rig, controlling the length of its steps as it walks.
	'''
    filePath = cmds.internalVar(
        usd=True
    ) + 'SpiderGen/spider.ma'  #the file path at which the spider model should exist
    fileExists = cmds.file(filePath, q=True,
                           ex=True)  #queries whether the file exists

    if fileExists is True:
        #selects all of the spiralling curves and connects them, providing a 'path' for the spiders movement.
        cmds.select(str(input_namespace) + 'curve_spiral*')
        curves = cmds.ls(selection=True)
        path = cmds.attachCurve(curves,
                                n=str(input_namespace) + 'spiderpath',
                                rpo=False)
        cmds.rebuildCurve(path, rt=3)
        cmds.hide(path)
        cmds.file(filePath, i=True)

        #renames the spider and it's callable controllers so that they are using the current 'namespace'.
        cmds.rename('SPIDER_RIG', str(input_namespace) + 'SPIDER_RIG')
        cmds.rename('SCALE_HANDLE',
                    str(input_namespace) + 'CONTROLLER_ScaleMe')
        cmds.rename('CONTROLLER', str(input_namespace) + 'CONTROLLER')

        #selects the scale controller and the path and connects them to a path animation.
        cmds.select(str(input_namespace) + 'CONTROLLER_ScaleMe', path)
        cmds.pathAnimation(stu=startTime,
                           etu=endTime,
                           f=True,
                           fa='x',
                           ua='y',
                           name=str(input_namespace) + 'motionpath')

        #creates a command that links the controller rotation to the 'length' of the animation.
        command = str(input_namespace) + 'CONTROLLER.rotateX = ' + str(
            input_namespace) + 'motionpath_uValue.output * ' + str(
                (endTime - startTime) / 10)
        #creates an expression of that command which is used for moving the legs as the spider moves around the path.
        cmds.expression(name=str(input_namespace) + 'leg_movement',
                        alwaysEvaluate=True,
                        s=command)
    else:
        #an error window for if the file is not found
        cmds.confirmDialog(
            title='Error',
            message='Spider Model not found, please ensure it located at: ' +
            str(filePath),
            button=['OK'],
            cancelButton='OK')

    return fileExists  #so that the grouping functions know not to expect the spider model or motionpath
예제 #41
0
	def _setDistance(self):
		''' 
		Creates expression
		Exp: moveVector = currentPosition - oldPosition
		'''
		exp = 'vector $move = <<%s.mvx,%s.mvy,%s.mvz>>;\n'%(self.node,self.node,self.node)
		exp += '%s.distance = mag($move);\n'%self.node

		cmds.expression(s=exp,n='%s_distExp'%self.ctrlName)	
예제 #42
0
def createRamdomRotationInSpace(CNT=None, targets=None, nameNode='RAMDOMSIN_'):

    if not cmds.attributeQuery(nameNode + 'AMPLITUDE', n=CNT, exists=True):
        cmds.addAttr(CNT,
                     shortName=nameNode + 'AMPLITUDE',
                     longName=nameNode + 'AMPLITUDE',
                     defaultValue=0,
                     k=True)
    if not cmds.attributeQuery(nameNode + 'FRECUENCY_X', n=CNT, exists=True):
        cmds.addAttr(CNT,
                     shortName=nameNode + 'FRECUENCY_X',
                     longName=nameNode + 'FRECUENCY_X',
                     defaultValue=0.6,
                     k=True)
    if not cmds.attributeQuery(nameNode + 'FRECUENCY_Y', n=CNT, exists=True):
        cmds.addAttr(CNT,
                     shortName=nameNode + 'FRECUENCY_Y',
                     longName=nameNode + 'FRECUENCY_Y',
                     defaultValue=0.8,
                     k=True)
    if not cmds.attributeQuery(nameNode + 'FRECUENCY_Z', n=CNT, exists=True):
        cmds.addAttr(CNT,
                     shortName=nameNode + 'FRECUENCY_Z',
                     longName=nameNode + 'FRECUENCY_Z',
                     defaultValue=-0.5,
                     k=True)
    if not cmds.attributeQuery(nameNode + 'TIME_OFFSET_X', n=CNT, exists=True):
        cmds.addAttr(CNT,
                     shortName=nameNode + 'TIME_OFFSET_X',
                     longName=nameNode + 'TIME_OFFSET_X',
                     defaultValue=0.0,
                     k=True)
    if not cmds.attributeQuery(nameNode + 'TIME_OFFSET_Y', n=CNT, exists=True):
        cmds.addAttr(CNT,
                     shortName=nameNode + 'TIME_OFFSET_Y',
                     longName=nameNode + 'TIME_OFFSET_Y',
                     defaultValue=0.0,
                     k=True)
    if not cmds.attributeQuery(nameNode + 'TIME_OFFSET_Z', n=CNT, exists=True):
        cmds.addAttr(CNT,
                     shortName=nameNode + 'TIME_OFFSET_Z',
                     longName=nameNode + 'TIME_OFFSET_Z',
                     defaultValue=0.0,
                     k=True)

    cmds.expression(
        s=str(targets) + ".rx = sin( time*" + str(CNT) + '.' + nameNode +
        'FRECUENCY_X+' + str(CNT) + '.' + nameNode + 'TIME_OFFSET_X' + ")*" +
        str(CNT) + '.' + nameNode + 'AMPLITUDE' + ";\n" + str(targets) +
        ".ry = sin( time*" + str(CNT) + '.' + nameNode + 'FRECUENCY_Y+' +
        str(CNT) + '.' + nameNode + 'TIME_OFFSET_Y' + ")*" + str(CNT) + '.' +
        nameNode + 'AMPLITUDE' + ";\n" + str(targets) + ".rz = sin( time*" +
        str(CNT) + '.' + nameNode + 'FRECUENCY_Z+' + str(CNT) + '.' +
        nameNode + 'TIME_OFFSET_Z' + ")*" + str(CNT) + '.' + nameNode +
        'AMPLITUDE' + ";",
        n=nameNode + 'RAMDOM_EXP')
예제 #43
0
	def _setMoveVector(self):
		''' 
		Creates expression
		Exp: Using currentPosition, oldPosition, get moveVector. 
		'''
		exp = '%s.mvx = %s.cpx - %s.ppx;\n'%(self.node,self.node,self.node)
		exp += '%s.mvy = %s.cpy - %s.ppy;\n'%(self.node,self.node,self.node)
		exp += '%s.mvz = %s.cpz - %s.ppz;\n'%(self.node,self.node,self.node)

		cmds.expression(s=exp,n='%s_moveVecExp'%self.ctrlName)	
예제 #44
0
def createShoulderIndicator(trackway):
    shoulders, shape = cmds.polyCube(name='shoulders', width=15, height=15, depth=15)
    groupItems.append(shoulders)
    cmds.move(0, 100, 0, shoulders)

    manus = trackway.manus
    cmds.expression("%s.z = 0.5*abs(%s.z - %s.z) + min(%s.z, %s.z)" % (
        shoulders, manus.left, manus.right, manus.left, manus.right))

    return shoulders
 def _set_expression(cls, driven_ctl, driver_ctl, attr_dict):
     expression = ''
     for k, v in attr_dict.iteritems():
         if mc.getAttr('%s.%s' % (driven_ctl, k), lock=True):
             mc.setAttr('%s.%s' % (driven_ctl, k),
                        lock=False,
                        keyable=True,
                        channelBox=True)
         expression += '%s.%s = %s.%s;' % (driven_ctl, k, driver_ctl, v)
     mc.expression(s=expression)
예제 #46
0
	def _setMoveVector(self):
		''' 
		Creates expression
		Exp: Using currentPosition, oldPosition, get moveVector. 
		'''
		exp = '%s.mvx = %s.cpx - %s.ppx;\n'%(self.node,self.node,self.node)
		exp += '%s.mvy = %s.cpy - %s.ppy;\n'%(self.node,self.node,self.node)
		exp += '%s.mvz = %s.cpz - %s.ppz;\n'%(self.node,self.node,self.node)

		cmds.expression(s=exp,n='%s_moveVecExp'%self.ctrlName)	
예제 #47
0
def AngleD():
	tar_jo = list(range(3))
	exps = list(range(0))

	jnt = mc.ls(sl=True)
	tar = mc.listRelatives('{}'.format(jnt[0]))
	par = mc.listRelatives('{}'.format(jnt[0]), p=True)
	mc.addAttr(ln='bendH', sn='bh', at='doubleAngle')
	mc.addAttr(ln='bendV', sn='bv', at='doubleAngle')
	mc.addAttr(ln='aimVector', nc=3, at='double3')
	for i in range(3):
		mc.addAttr(ln='aimVector{}'.format(xyz[i]), at='double', p='aimVector')

	spc = mc.group(em=True, n='{}_driver'.format(jnt[0]))
	mc.parent(spc, jnt[0])
	for i in range(3):
		mc.setAttr('{0}.translate{1}'.format(spc, xyz[i]), 0)
		mc.setAttr('{0}.rotate{1}'.format(spc, xyz[i]), 0)


	#createNode
	vep = mc.createNode('vectorProduct', n='{}_vectorProduct'.format(jnt[0]))
	exp = mc.expression(n='{}_Exp'.format(jnt[0]), o='{}'.format(jnt[0]))
	mc.expression(exp, e=True, uc='none', ae=0)


	#setAttr
	mc.setAttr('{}.input1X'.format(vep), 1.0)
	mc.setAttr('{}.operation'.format(vep), 3)
	mc.setAttr('{}.normalizeOutput'.format(vep), True)

	#connectAttr
	mc.connectAttr('{}.matrix'.format(spc), '{}.matrix'.format(vep))
	mc.connectAttr('{0}.output[0]'.format(exp), '{}.bendH'.format(jnt[0]))
	mc.connectAttr('{0}.output[1]'.format(exp), '{}.bendV'.format(jnt[0]))
	for i in range(3):
		mc.connectAttr('{0}.output{1}'.format(vep, xyz[i]), '{0}.aimVector{1}'.format(jnt[0], xyz[i]))
		mc.connectAttr('{0}.aimVector{1}'.format(jnt[0], xyz[i]), '{0}.input[{1}]'.format(exp, i))
		mc.connectAttr('{0}.translate{1}'.format(jnt[0], xyz[i]), '{0}.translate{1}'.format(spc, xyz[i]))
		mc.connectAttr('{0}.rotate{1}'.format(jnt[0], xyz[i]), '{0}.rotate{1}'.format(spc, xyz[i]))
		mc.connectAttr('{0}.scale{1}'.format(jnt[0], xyz[i]), '{0}.scale{1}'.format(spc, xyz[i]))
		mc.connectAttr('{0}.shear{1}'.format(jnt[0], xyz[i]), '{0}.shear{1}'.format(spc, xyz[i]))


	#expression
	exps.append('vector $x_vec = <<1., .0, .0>>;')
	exps.append('vector $y_vec = <<.0, 1., .0>>;')
	exps.append('vector $z_vec = <<.0, .0, 1.>>;')
	exps.append('vector $vec = <<' + jnt[0] + '.aimVectorX, ')
	exps.append(jnt[0] + '.aimVectorY, ' + jnt[0] + '.aimVectorZ>>;')
	exps.append('float $aim = dot($x_vec, $vec) + 1;')
	exps.append(jnt[0] + '.bendH = atan2(dot($z_vec, $vec), $aim) * -2.;')
	exps.append(jnt[0] + '.bendV = atan2(dot($y_vec, $vec), $aim) * 2.;')
	imp = ''.join(exps)
	mc.expression(exp, e=True, s='{}'.format(imp))
예제 #48
0
def _create_FOAM_FluidTexture(oceanShader = '', size = '', pathToPreset = '', foamFluidShapeName = CONST.FOAM_FLUID_SHAPENODE):
    """
    create a 3d fluid texture for FOAM, make it a 2d simulation and texture the foamOffset of the ocean shader with it's outAlpha.
    """
    debug(None, method = 'fluids_lib._create_FOAM_FluidTexture', message = 'Building fluid %s' % foamFluidShapeName, verbose = False)
    fluidShape = cmds.shadingNode('fluidTexture3D', asTexture = True, name = foamFluidShapeName)

    # Get parent of shape and set attrs
    fluid = cmds.listRelatives(fluidShape, parent= True)
    _setBaseFluidAttrs(fluid)

    ## Connect to time
    cmds.connectAttr ("time1.outTime",(fluidShape + ".currentTime"))
    debug(None, method = 'fluids_lib._create_FOAM_FluidTexture', message = '%s connected to time1' % fluidShape, verbose = False)

    ## Apply foam preset
    mel.eval("""applyPresetToNode " """+fluidShape+""" " "" "" "%s" 1;""" % pathToPreset)
    debug(None, method = 'fluids_lib._create_FOAM_FluidTexture', message = 'Mel preset applied: %s' % pathToPreset, verbose = False)


    #add expression to texture
    expStringList = [
                    "float $foamSpeed = 1.0;\n",
                     "%s.textureTime = time * $foamSpeed;\n" % fluidShape
                    ]
    utils.checkExpressionExists('s_foamTexture_Speed')
    cmds.expression(n = '%s_foamTexture_Speed' % fluidShape,  string = utils.processExpressionString(expStringList))

    expStringList = [
                    'int $width = %s.dimensionsW;\r\n' % fluidShape,
                    'int $height = %s.dimensionsH;\r\n' % fluidShape,
                    'if ($width>= $height)\r\n',
                    '{\r\n',
                    '%s.baseResolution = $width*2;\r\n' % fluidShape,
                    '}\r\n',
                    'else\r\n',
                    '{\r\n',
                    '%s.baseResolution = $height*2;\r\n' % fluidShape,
                    '}'
                    ]
    #expression to maintain resolution/container size relationship
    cmds.expression(n = '%s_foamTexture_ContainerSize' % fluidShape, string = utils.processExpressionString(expStringList))
    debug(None, method = 'fluids_lib._create_FOAM_FluidTexture', message = ' Expression %s_foamTexture_ContainerSize built' % fluidShape, verbose = False)

    baseTextureName = fluidShape.split('Shape')[0]
    cmds.rename(fluid[0], '%s' % baseTextureName)
    utils.createTypeTag(obj = '%s' % baseTextureName, typeName = '%s' % baseTextureName)
    debug(None, method = 'fluids_lib._create_FOAM_FluidTexture', message = ' Rename and Tag successful..', verbose = False)

    ## Connect fluid to ocean shader
    cmds.connectAttr("%s.outAlpha" % fluidShape, "%s.foamOffset" % oceanShader, force = True)

    debug(None, method = 'fluids_lib._create_FOAM_FluidTexture', message = ' Returning %s:' % fluidShape, verbose = False)
    return fluidShape
예제 #49
0
def animerDeformation(lenteur, nomDeform):
    nom = str(nomDeform) + "_Expression"
    if (not cmds.objExists(nom)):
        cmds.expression(n=nom,
                        s=nomDeform + ".offset = time1.outTime/" +
                        str(lenteur))
    else:
        cmds.expression(nom,
                        e=True,
                        s=nomDeform + ".offset = time1.outTime/" +
                        str(lenteur))
예제 #50
0
파일: mentalray.py 프로젝트: tccoleman/rush
 def _misss_fast_skin_maya(self):
     node = cmds.shadingNode('misss_fast_skin_maya', asShader=True)
     tex = cmds.shadingNode('mentalrayTexture', asTexture=True)
     cmds.expression(string="%s.miWidth  = defaultResolution.width * 2" %
                     tex)
     cmds.expression(string="%s.miHeight = defaultResolution.height" % tex)
     cmds.setAttr(tex + ".miWritable", 1)
     cmds.setAttr(tex + ".miDepth", 4)
     lmap = cmds.shadingNode('misss_fast_lmap_maya', asUtility=True)
     cmds.connectAttr(tex + '.message', node + '.lightmap')
     cmds.connectAttr(tex + '.message', lmap + '.lightmap')
예제 #51
0
 def _misss_fast_skin_maya(self):
     node = cmds.shadingNode('misss_fast_skin_maya', asShader=True)
     tex = cmds.shadingNode('mentalrayTexture', asTexture=True)
     cmds.expression(
         string="%s.miWidth  = defaultResolution.width * 2" % tex)
     cmds.expression(string="%s.miHeight = defaultResolution.height" % tex)
     cmds.setAttr(tex + ".miWritable", 1)
     cmds.setAttr(tex + ".miDepth", 4)
     lmap = cmds.shadingNode('misss_fast_lmap_maya', asUtility=True)
     cmds.connectAttr(tex + '.message', node + '.lightmap')
     cmds.connectAttr(tex + '.message', lmap + '.lightmap')
예제 #52
0
def createMainExpression(objectNameEmitter=""):
    """
    creating main expression for the scene
    @param objectNameEmitter: Name of objectNameEmitter
    @type objectNameEmitter: String
    --------------------------------------------
    @return: 0-ExpressionText
    """
    newExp = "////////////////////////////// Main Expression //////////////////////////////\n\n"
    cmds.expression (o=objectNameEmitter, string=newExp, alwaysEvaluate=1, unitConversion="all", name = "ocean_MainExpression")
    
    return newExp
예제 #53
0
 def createGCTRL(self, *args):
     if cmds.objExists('gravCTRL'):
         cmds.error('请勿重复创建')
         cmds.select('gravCTRL')
     else:
         cmds.curve(n='pvGravArrow', d=1,
                    p=[(0, 15, 0), (-4, 4, -4), (4, 4, -4), (0, 15, 0), (4, 4, 4), (-4, 4, 4), (0, 15, 0),
                       (4, 4, -4),
                       (2, 4, -2), (3, -15, -3), (-3, -15, -3), (-2, 4, -2), (-4, 4, -4), (-4, 4, 4), (-2, 4, 2),
                       (-3, -15, 3), (3, -15, 3),
                       (2, 4, 2), (4, 4, 4), (4, 4, -4), (2, 4, -2), (-2, 4, -2), (-2, 4, 2), (2, 4, 2), (2, 4, -2),
                       (2, 4, -2), (3, -15, -3),
                       (3, -15, 3), (-3, -15, 3), (-3, -15, -3)], k=range(30))
         cmds.rotate(180, 0, 0)
         cmds.makeIdentity(apply=True, t=True, r=True, s=True, n=True)
         getShape = cmds.listRelatives(s=True, pa=True)[0]
         cmds.rename(getShape, 'pvGravArrowShape')
         cmds.spaceLocator(n='pvGravOrigin')
         cmds.setAttr('pvGravOrigin.visibility', 0)
         cmds.spaceLocator(n='pvGravAim')
         cmds.setAttr('pvGravAim.visibility', 0)
         cmds.group('pvGravAim', n='pvGravAim_Null')
         cmds.setAttr('pvGravAim.translateY', -1)
         cmds.aimConstraint('pvGravAim', 'pvGravOrigin')
         cmds.group('pvGravArrow', n='gravCTRL')
         cmds.parentConstraint('gravCTRL', 'pvGravAim_Null')
         cmds.select('pvGravArrowShape', 'gravCTRL')
         cmds.parent(r=True, s=True)
         cmds.delete('pvGravArrow')
         cmds.pointConstraint('gravCTRL', 'pvGravOrigin')
         cmds.pickWalk(direction="up")
         cmds.addAttr(ln='dynamicAmplitude', nn='Dynamic  Amplitude', at='float', dv=1);
         cmds.setAttr('gravCTRL.dynamicAmplitude', k=True)
         cmds.expression(s='pvGravAim.translateY=gravCTRL.dynamicAmplitude*-1')
         cmds.setAttr('pvGravArrowShape.overrideEnabled', 1)
         cmds.setAttr('pvGravArrowShape.overrideColor', 6)
         cmds.group('pvGravOrigin', 'pvGravAim_Null', 'gravCTRL', n='gravCTRL_GRP')
         cmds.setAttr('gravCTRL_GRP.translateX', k=False, l=True)
         cmds.setAttr('gravCTRL_GRP.translateY', k=False, l=True)
         cmds.setAttr('gravCTRL_GRP.translateZ', k=False, l=True)
         cmds.setAttr('gravCTRL_GRP.rotateX', k=False, l=True)
         cmds.setAttr('gravCTRL_GRP.rotateY', k=False, l=True)
         cmds.setAttr('gravCTRL_GRP.rotateZ', k=False, l=True)
         cmds.setAttr('gravCTRL_GRP.scaleX', k=False, l=True)
         cmds.setAttr('gravCTRL_GRP.scaleY', k=False, l=True)
         cmds.setAttr('gravCTRL_GRP.scaleZ', k=False, l=True)
         cmds.setAttr('gravCTRL_GRP.visibility', k=False, l=True)
         for eachNucleus in cmds.ls(type='nucleus'):
             cmds.connectAttr('pvGravOrigin_aimConstraint1.constraintVectorX', '%s.gravityDirectionX' % eachNucleus)
             cmds.connectAttr('pvGravOrigin_aimConstraint1.constraintVectorY', '%s.gravityDirectionY' % eachNucleus)
             cmds.connectAttr('pvGravOrigin_aimConstraint1.constraintVectorZ', '%s.gravityDirectionZ' % eachNucleus)
         cmds.select('gravCTRL');
예제 #54
0
def	constrain_locator_to_vertex	():
#	_camera		=	Camera()
	_vertex		=	cmds.ls (selection = True)[0]
	_geo			=	_vertex[:_vertex.rfind('.')]
	_locator		=	cmds.createNode	('locator')
	_locator	=	cmds.pickWalk (direction = 'up')[0]
#	cmds.aimConstraint (_camera.transform, _locator, worldUpType = 'objectrotation', worldUpObject = _camera.transform)
	cmds.expression		(string	='''
float $BBoxSize = '''	+	_geo	+	'''.boundingBoxMinX;\n
float $vertexWorldPos[3] = `pointPosition -world '''		+	_vertex	+	'''`;\n'''	+
_locator	+	'''.translateX = $vertexWorldPos[0];\n'''	+
_locator	+	'''.translateY = $vertexWorldPos[1];\n'''	+
_locator	+	'''.translateZ = $vertexWorldPos[2];'''	)
def	constrain_locator_to_vertex	():
	vertex		= cmds.ls (selection = True)[0]
	geo			= vertex[:vertex.rfind('.')]
	locator		= cmds.createNode	('locator')
	locator		= cmds.listRelatives (locator, parent = True)[0]
	locator		= cmds.rename (locator, 'locator_vertexConstrained')
	#locator		= cmds.pickWalk (direction = 'up')[0]
	cmds.expression	(name = locator, string	='''
float $BBoxSize = '''	+	geo	+	'''.boundingBoxMinX;\n
float $vertexWorldPos[3] = `pointPosition -world '''		+	vertex	+	'''`;\n'''	+
locator	+	'''.translateX = $vertexWorldPos[0];\n'''	+
locator	+	'''.translateY = $vertexWorldPos[1];\n'''	+
locator	+	'''.translateZ = $vertexWorldPos[2];'''	)
예제 #56
0
 def createBtnCmd(self, *args):
     # Creates a function for the radio button group.
     self.objIndAsCmd = {1:mc.polyCube, 2:mc.polyCone, 3:mc.polyCylinder, 4:mc.polySphere}
     # Creates the object variable for the create function.
     objIndex = mc.radioButtonGrp(self.objType, query = True, select = True)
     # Creates a variable for the new object to be created based on the above array and objIndex variable.
     newObject = self.objIndAsCmd[objIndex]()
    
     # Following section creates necessary variables for the expression.
     # Creates a variable to select the previously created object.
     sel = mc.ls(sl=True)
     # Creates the attribute variable using the user input from the GUI.
     att = mc.textField(self.attribute, query = True, text = True)
     # Creates the minimum value variable using the user input from the GUI.
     minimum = mc.floatField(self.min, query = True, value = True)
     # Creates the maximum value variable using the user input from the GUI.
     maximum = mc.floatField(self.max, query = True, value = True)
     # Creates the time period variable using the user input from the GUI.
     period = mc.floatField(self.time, query = True, value = True)
     # Creates the variable for the type of oscillation radio group.
     oscType = mc.radioButtonGrp(self.oscillate, query = True, select = True)
     # Creates the speed variable for which the created object will travel at.
     speed = 6.28/period
     # Creates the random variable.  It is created as 'ran' because random is a pre-defined function in python.
     ran = (maximum - minimum)/2.0
     # Creates the start variable.
     start = minimum + ran
     
    
     # Creates the expression that will drive the script.
     # objectName.attributeName = sin(time*speed) * range + start.
     # Creates the expression for the cos oscillation.
     expressionTextCos = (sel[0] + "." + str(att)
                       + " = cos(time * " + str(speed)
                       + " ) * " + str(ran) + " + "
                       + str(start) + ";")
     
     # Creates the expression for sin
     expressionTextSin = (sel[0] + "." + str(att)
                       + " = sin(time * " + str(speed)
                       + " ) * " + str(ran) + " + "
                       + str(start) + ";")
     # Calls the expression.
     if oscType == 1:
         mc.expression(string=expressionTextSin)
         print "ExpressionSin has sucessfully run."
     elif oscType == 2:
         mc.expression(string=expressionTextCos)
         print "ExpressionCos has successfully run."
     else:
         print "Expression didn't properly execute."
예제 #57
0
def createHipsIndicator(trackway):
    hips, shape = cmds.polyCube(name='hips', width=20, height=20, depth=20)
    cmds.move(0, 100, 0, hips)
    references.append(hips)

    shoulders, shape = cmds.polyCube(name='shoulders_locked', width=15, height=15, depth=15)
    cmds.move(0, 115, trackway.spineLength, shoulders)
    cmds.parent(shoulders, hips, absolute=True)

    pes = trackway.pes
    cmds.expression("%s.z = 0.5*abs(%s.z - %s.z) + min(%s.z, %s.z)" % (
        hips, pes.left, pes.right, pes.left, pes.right))

    return hips
예제 #58
0
        def CreateSine(self , tailName , Envelope , Amplitude , Wavelength , WaveFollow , StartingPosition , objList,Axial):
                objNum = len(objList)
                averageNum = 1.000/(objNum - 1)
                expressionStr = ''
                for x in range(objNum):
                        StartingPosition_PMA01 = mc.shadingNode('plusMinusAverage',asUtility = True,name = tailName + '_' + Axial + '_StartingPosition0' + str(x) + '_PMA01')
                        mc.setAttr(StartingPosition_PMA01 + '.operation',1)
                        mc.setAttr(StartingPosition_PMA01 + '.input2D[0].input2Dx',objNum-1-x)
                        mc.connectAttr(StartingPosition,StartingPosition_PMA01 + '.input2D[1].input2Dx')

                        StartingPosition_SR = mc.shadingNode('setRange',asUtility = True,name = tailName + '_' + Axial + '_StartingPosition0' + str(x) + '_setRange')
                        mc.setAttr(StartingPosition_SR + '.maxX',1)
                        mc.setAttr(StartingPosition_SR + '.oldMaxX',objNum)
                        mc.connectAttr(StartingPosition_PMA01 + '.output2Dx',StartingPosition_SR + '.valueX')

                        StartingPosition_PMA02 = mc.shadingNode('plusMinusAverage',asUtility = True,name = tailName + '_' + Axial + '_StartingPosition0' + str(x) + '_PMA02')
                        mc.setAttr(StartingPosition_PMA02 + '.operation',2)
                        mc.setAttr(StartingPosition_PMA02 + '.input2D[0].input2Dx',1)
                        mc.connectAttr(StartingPosition_SR + '.outValueX',StartingPosition_PMA02 + '.input2D[1].input2Dx')

                        Envelope_MD = mc.shadingNode('multiplyDivide',asUtility = True,name = tailName + '_' + Axial + '_Envelope0' + str(x) + '_MD')
                        mc.connectAttr(Envelope,Envelope_MD + '.input1X')
                        mc.connectAttr(StartingPosition_PMA02 + '.output2Dx',Envelope_MD + '.input2X')

                        Amplitude_MD = mc.shadingNode('multiplyDivide',asUtility = True,name = tailName + '_' + Axial + '_Amplitude0' + str(x) + '_MD')
                        mc.connectAttr(Amplitude,Amplitude_MD + '.input1X')
                        mc.connectAttr(Envelope_MD + '.outputX',Amplitude_MD + '.input2X')

                        result_MD = mc.shadingNode('multiplyDivide',asUtility = True,name = tailName + '_' + Axial + '_result0' + str(x) + '_MD')
                        mc.connectAttr(Amplitude_MD + '.outputX',result_MD + '.input1X')
                        mc.connectAttr(result_MD + '.outputX',objList[x] + '.translate' + Axial)

                        Wavelength_MD = mc.shadingNode('multiplyDivide',asUtility = True,name = tailName + '_' + Axial + '_Wavelength0' + str(x) + '_MD')
                        mc.connectAttr(Wavelength,Wavelength_MD + '.input1.input1X')
                        WavelengthMulriple = averageNum * x
                        mc.setAttr(Wavelength_MD + '.input2X',WavelengthMulriple)

                        WaveFollow_MD = mc.shadingNode('multiplyDivide',asUtility = True,name = tailName + '_' + Axial + '_WaveFollow0' + str(x) + '_MD')
                        mc.connectAttr(WaveFollow,WaveFollow_MD + '.input1.input1X')
                        mc.setAttr(WaveFollow_MD + '.input2X',-1)

                        sine_PMA = mc.shadingNode('plusMinusAverage',asUtility = True,name = tailName + '_' + Axial + '_sine0' + str(x) + '_PMA')
                        mc.connectAttr(Wavelength_MD + '.outputX',sine_PMA + '.input2D[0].input2Dx')
                        mc.connectAttr(WaveFollow_MD + '.outputX',sine_PMA + '.input2D[1].input2Dx')

                        expressionStr01 = result_MD +  '.input2X' + ' = ' + 'sin(' + sine_PMA + '.output2Dx);' + '\n'
                        expressionStr = expressionStr + expressionStr01

                mc.expression(s = expressionStr,name = 'sine' + '_' + Axial,ae = True,uc = all)
def makeChild(parentObj,makeCon):
     
    # DUPLICATE
    newObj = cmds.duplicate(parentObj,rr=True,ilf=True,rc=True)[0]
    
    
    # PARENT
    cmds.parent(newObj,parentObj)
    
    # CONNECT XFORM ATTRS
    if makeCon:
        for attr in attrs:
            cmds.expression(s = newObj+'.' +attr+ ' = ' + parentObj+'.' +attr)
    
    return newObj