예제 #1
0
 def invertCurve(self, animationCurve):
     """ Scale the values by negative one, """
     pm.scaleKey(
         animationCurve,
         valueScale=-1,
         valuePivot=0,
     )
예제 #2
0
    def scaleChara(self, mayaFalse):

        #this part does the importing and admin stuff
        try:
            pm.createReference(
                '//p.sv/Prism/project/Parallel/element/character_Roll/scenes/'
                + pm.optionMenu(self.charalist, q=True, value=True)[-4:-1] +
                '001_SP01.mb',
                namespace=':')
        except:
            pm.confirmDialog(title=u'Parallel scaling',
                             message=u'Parallel フォルダーの許可がないです。')
        #this part does the scaling
        pm.optionMenu('listofchara', q=True, value=True)
        inverseScale = 1 / self.nameScale[pm.optionMenu(
            self.charalist, q=True, value=True)]
        pm.scale('Reference|Root', inverseScale, inverseScale, inverseScale)

        for i in pm.listRelatives('Reference', ad=True, type='joint'):
            try:
                pm.copyKey(i)
                pm.pasteKey(i.replace('Reference', 'Reference1'))
            except:
                print 'no keys to copypasta'
        pm.scaleKey('Reference1|Root|Hips',
                    valueScale=inverseScale,
                    valuePivot=0,
                    attribute='translate')

        #this part cleans up the file
        pm.delete('Reference')
        pm.listReferences()[0].importContents(removeNamespace=False)
        pm.rename('Reference1', 'Reference')
예제 #3
0
def convertFrameRate(fromFPS, toFPS, nodes='all'):
    '''

    :param fromFPS: originial frame rate, eg 25
    :param toFPS: target frame rate, eg 24
    :param nodes: the nodes to scale. All will scale all keyframes in the scene
    :return: scaledKeys: Nr of keys to be scaled

    example:
    convertFrameRate(25, 24, nodes='all')
    '''
    scaledKeys = []

    by = (float(fromFPS) * 1.0000000) / (float(toFPS) * 1.000000)
    print 'Scaling by %s' % by

    if nodes == 'all':
        anim_curves = cmds.ls(
            type=['animCurveTA', 'animCurveTL', 'animCurveTT', 'animCurveTU'])
    else:
        anim_curves = nodes

    for each in anim_curves:
        try:
            pm.scaleKey(each, timeScale=by)
            scaledKeys.append(each)
        except:
            pass
    print 'Done. Scaled %s Keyframe by %s' % (len(scaledKeys), by)
    return len(scaledKeys)
예제 #4
0
	def spaceScale(attr, cvNew, scale):
		"""
		"""
		# Translate
		if attr.startswith('translate'):
			pm.scaleKey(cvNew, vs= scale, vp= 0, ssk= False)
		# Scale
		if attr.startswith('scale'):
			pm.scaleKey(cvNew, vs= scale, vp= 1, ssk= False)
예제 #5
0
	def keyMirror(attr, cvNew, mirror):
		"""
		"""
		for axis in mirror:
			# Translate
			if axis.startswith('t') and attr.startswith('translate' + axis[-1].upper()):
				pm.scaleKey(cvNew, vs= -1, vp= 0, ssk= False)
			# Rotation
			if axis.startswith('r') and attr.startswith('rotate' + axis[-1].upper()):
				pm.scaleKey(cvNew, vs= -1, vp= 0, ssk= False)
예제 #6
0
def scaleKeyframes(by=1.041666666666667, nodes='all'):
    # to do a scene conversion from 25 to 24 frames per sec
    if nodes == 'all':
        anim_curves = cmds.ls(
            type=['animCurveTA', 'animCurveTL', 'animCurveTT', 'animCurveTU'])
    else:
        anim_curves = nodes

    for each in anim_curves:
        pm.scaleKey(each, timeScale=by)
    print 'Done. Scaled %s Keyframe' % len(anim_curves)
예제 #7
0
def reverseCurve( timePiv=None ):
    """
    Reverse the selected curve(s). If timePiv is C{'None'}, curve will be reversed at current time.

    @param timePiv: timePiv: C{None} If timePiv is C{'None'}, curve will be reversed at current time.
    @type timePiv: float
    """
    for curve in getSelectedCurvesKeys().iterkeys():
        if timePiv is None:
            timePiv = ( pm.findKeyframe( curve, which='first' ) + pm.findKeyframe( curve, which='last' ) ) / 2
        else:
            pass
        pm.scaleKey( curve, timeScale= -1.0, timePivot=timePiv )
예제 #8
0
    def scale_keys_value_multi(self):
        """Scales each selected curve's keys independently on their own pivots"""

        # Go through each curve, finding the times and values for each and apply the pivot for that curve
        for curve in self.curves:
            self.key_values = self.get_key_values(curve)
            self.key_times = self.get_key_times(curve)
            pivot = self.get_pivot()

            for i in xrange(len(self.key_values)):
                pm.scaleKey(curve,
                            valuePivot=pivot,
                            valueScale=self.scale,
                            time=(self.key_times[i], self.key_times[i]))
예제 #9
0
def scaleani(arg):
	selACs = pm.textScrollList("keyattr",q=1,si=1) 
	start = pm.textField('startnum',q=True,tx=True)
	end =pm.textField('endnum',q=True,tx=True)
	sel = pm.ls(sl=1)
	if sel !=[]:
		for i in range(len(sel)):
			selAC = pm.listConnections(sel[i],d=0,type="animCurve")
			if selAC !=[]:
				selattr = pm.listConnections(sel[i],d=0,plugs=1,type="animCurve")
				for a in range(len(selattr)):
					aniattr =  pm.listConnections(selattr[a],s=0,plugs=1)
					if aniattr!=[]:
						if aniattr[0] in selACs:
							attrname =  str(aniattr[0])[(len(aniattr[0].split(".")[0])+1):]
							pm.scaleKey(iub=False,newStartTime=start,newEndTime=end,attribute=attrname)
예제 #10
0
def flipCurve( curves=None, valuePiv=None ):
    """
    Flip the selected curve(s). If valuePiv is C{'None'}, curve will be flipped over value at current time.

    @param valuePiv: default: C{None} If valuePiv is C{'None'}, curve will be flipped over value at current time.
    @type valuePiv: float
    """
    if curves is None:
        curves = getSelectedCurvesKeys().iterkeys()

    for curve in curves:
        if valuePiv is None:
            valuePiv = pm.keyframe( curve, query=True, eval=True )[0]
        else:
            pass
        pm.scaleKey( curve, valueScale= -1.0, valuePivot=valuePiv )
예제 #11
0
    def scale_keys_time_multi(self):
        """Scales each selected curve's keys independently in time on their own pivots"""

        for curve in self.curves:
            self.key_times = self.get_key_times(curve)

            # if we're scaling time from the last key, we need to iterate backwards through the scaling or some values
            # will give weird results as the first keys end up after ones not yet scaled
            if self.pivot == 'pivot_last_time':
                key_range = reversed(xrange(len(self.key_times)))
            else:
                key_range = xrange(len(self.key_times))

            for i in key_range:
                pm.scaleKey(curve,
                            timePivot=(self.get_pivot()),
                            timeScale=self.scale,
                            time=(self.key_times[i], self.key_times[i]))

            pm.snapKey(tm=1.0)
예제 #12
0
    def scale_keys_time(self):
        """Scales all selected keys in time from a single pivot for all"""
        pm.scaleKey(timePivot=(self.get_pivot()), timeScale=self.scale)

        # Snap all keys so there are no subframe keys
        pm.snapKey(tm=1.0)
예제 #13
0
 def scale_keys_value(self):
     """Scales all selected keys in value from a single pivot for all"""
     pm.scaleKey(valuePivot=self.get_pivot(), valueScale=self.scale)