def convertConnectionAsAnimCurve( node, attr ):
separateParentConnection( node, attr )
cons = cmds.listConnections( node+'.'+attr, s=1, d=0, p=1, c=1 )
if not cons: return None
attrType = cmds.attributeQuery( attr, node= node, attributeType=1 )
if attrType == 'doubleLinear':
animCurveType= 'animCurveUL'
elif attrType == 'doubleAngle':
animCurveType = 'animCurveUA'
else:
animCurveType = 'animCurveUU'
animCurve = cmds.createNode( animCurveType )
cmds.connectAttr( cons[1], animCurve+'.input' )
cmds.connectAttr( animCurve+'.output', cons[0], f=1 )
cmds.setKeyframe( animCurve, f= -1, v= -1 )
cmds.setKeyframe( animCurve, f=-.5, v=-.5 )
cmds.setKeyframe( animCurve, f= 0, v= 0 )
cmds.setKeyframe( animCurve, f= .5, v= .5 )
cmds.setKeyframe( animCurve, f= 1, v= 1 )
cmds.setAttr( animCurve + ".postInfinity", 1 )
cmds.setAttr( animCurve + ".preInfinity", 1 )
cmds.selectKey( animCurve )
cmds.keyTangent( itt='spline', ott='spline' )
return animCurve
def setSmartKey(time=None, animCurves=None, select=True, insert=True, replace=True, addTo=False):
if not time: time = animMod.getTimelineTime()
getFrom = "timeline"
if not animCurves:
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
if animCurves and getFrom != "timeline":
cmds.setKeyframe(animCurves, time=time, insert=insert)
if select: cmds.selectKey(animCurves, replace=replace, addTo=addTo, time=time)
else:
objects = animMod.getObjsSel()
if objects:
channelboxSelObjs = animMod.channelBoxSel()
if channelboxSelObjs:
#objsAttrs = ["%s.%s"%(loopObj, loopChannelboxSel) for loopObj in objects for loopChannelboxSel in channelboxSel]
#key selected attributes in the channelbox
for n, loopObjAttr in enumerate(channelboxSelObjs):
prevKey = cmds.findKeyframe(loopObjAttr, time=(time,time), which="previous")
tangentType = cmds.keyTangent(loopObjAttr, query=True, outTangentType=True, time=(prevKey,prevKey))
if not tangentType: #if there is no key
tangentType = cmds.keyTangent(query=True, g=True, outTangentType=True)
inTangentType = tangentType[0].replace("fixed", "auto").replace("step", "auto")
outTangentType = tangentType[0].replace("fixed", "auto")
cmds.setKeyframe(loopObjAttr, time=time, insert=False, shape=False, inTangentType=inTangentType, outTangentType=outTangentType)
continue
inTangentType = tangentType[0].replace("fixed", "auto").replace("step", "auto")
outTangentType = tangentType[0].replace("fixed", "auto")
cmds.setKeyframe(loopObjAttr, time=time, insert=insert, shape=False, inTangentType=inTangentType, outTangentType=outTangentType)
else:
#allChannels = animMod.getAllChannels(objects)
#objAttrs = ["%s.%s"%(objects[n], loopAttr) for n, loopObj in enumerate(allChannels) for loopAttr in loopObj]
prevKeys = [cmds.findKeyframe(obj, time=(time,time), which="previous") for obj in objects]
tangentTypes = [cmds.keyTangent(obj, query=True, outTangentType=True, time=(prevKeys[n],prevKeys[n])) for n, obj in enumerate(objects)]
#prevKeys = [cmds.findKeyframe(obj, time=(time,time), which="previous") for obj in objAttrs]
#tangentTypes = [cmds.keyTangent(obj, query=True, outTangentType=True, time=(prevKeys[n],prevKeys[n])) for n, obj in enumerate(objAttrs)]
#key all atributes
cmds.setKeyframe(objects, time=time, insert=insert, shape=False)
#cmds.setKeyframe(objAttrs, time=time, insert=insert, shape=False)
if insert: #will force create key if there is no key
for n, loopTangent in enumerate(tangentTypes):
if not loopTangent:
cmds.setKeyframe(objects[n], time=time, insert=False, shape=False)
def flowAround(self, frames=2, excludeCurrKey=False):
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
if animCurves:
# if getFrom == "graphEditor":
keysSel = animMod.getTarget("keysSel", animCurves, getFrom)
tangentType = "flow"
time = None
# animMod.expandKeySelection(frames)
index = animMod.getTarget("keysIndexSel", animCurves, getFrom)
indexTimes = animMod.getTarget("keyIndexTimes", animCurves, getFrom)
# expand selection
for n, loopCurve in enumerate(index):
for x in xrange(frames):
if loopCurve[0] >= 1:
loopCurve.insert(0, loopCurve[0] - 1)
if loopCurve[-1] < indexTimes[n][-1]:
loopCurve.append(loopCurve[-1] + 1)
# if excludeCurrKey:
self.applyTangent(animCurves, tangentType, getFrom, time, index)
# select back keys
if keysSel:
cmds.selectKey(clear=True)
for n, aCurve in enumerate(animCurves):
for key in keysSel[n]:
cmds.selectKey(aCurve, addTo=True, time=(key, key))
def keyFullRotation (pObjectName, pStartTime, pEndTime, pTargetAttribute):
cmds.cutKey (pObjectName, time = (pStartTime, pEndTime), attribute=pTargetAttribute)
cmds.setKeyframe (pObjectName, time = pStartTime, attribute=pTargetAttribute, value=0)
cmds.setKeyframe (pObjectName, time = pEndTime, attribute=pTargetAttribute, value=360)
cmds.selectKey (pObjectName, time = (pStartTime, pEndTime), attribute=pTargetAttribute, keyframe=True)
cmds.keyTangent (inTangentType='linear', outTangentType='linear')
def getRoofSineCurve( startInput, endInput, minValue, maxValue ):
animCurve = cmds.createNode( 'animCurveUU' )
cmds.setKeyframe( f= startInput, v=minValue )
cmds.setKeyframe( f= (startInput+endInput)/2.0, v=maxValue )
cmds.setKeyframe( f= endInput, v=minValue )
cmds.selectKey( animCurve )
cmds.setInfinity( poi='cycle', pri='cycle' )
return animCurve
def goToKeyframe(option='next', roundFrame=False, selected=False, selectKeys=False, searchHierarchy=False):
'''
'''
if option != 'next' and option != 'previous':
OpenMaya.MGlobal.displayWarning('Option argument should be "next" or "previous"')
return
if selected and selectKeys:
OpenMaya.MGlobal.displayWarning('Cannot use selectKeys flag in conjunction with selected flag.')
selectKeys = False
sel = mc.ls(sl=True)
currentTime = mc.currentTime(query=True)
time = currentTime
if not sel:
if option == 'next':
time+=1
elif option == 'previous':
time-=1
else:
return
#if nothing is selected, just go to the next or previous keyframe
with utl.SkipUndo():
mc.currentTime(time)
return
keySel = utl.KeySelection()
if searchHierarchy:
#if we're looking through the hierarchy,
keySel.keyedInHierarchy()
else:
#create the keySelection object.
#all the heavy lifting is done in ml_utilities.
if selected and keySel.selectedKeys():
pass
if keySel.visibleInGraphEditor():
pass
if keySel.selectedObjects():
pass
time = keySel.findKeyframe(which=option, roundFrame=roundFrame, loop=True)
if selectKeys:
mc.selectKey(keySel.curves, time=(time,))
#finally, set the time without adding to the undo queue
with utl.SkipUndo():
mc.currentTime(time, edit=True)
def keyFullRotation(pObjectName, pStartTime, pEndTime, pTargetAttribute):
#The keys are deleted
cmds.cutKey(pObjectName, time=(pStartTime, pEndTime), attribute=pTargetAttribute)
#Define new keys for the animations (rotation in the axis Y).
cmds.setKeyframe(pObjectName, time= pStartTime, attribute=pTargetAttribute, value = 0)
cmds.setKeyframe(pObjectName,time=pEndTime, attribute=pTargetAttribute, value = 360)
#In order to mantain a constant rate of rotation with linear tangents
cmds.selectKey(pObjectName, time=(pStartTime, pEndTime), attribute=pTargetAttribute)
cmds.keyTangent( inTangentType='linear', outTangentType='linear')
def smoothAnimCurves(objects, isLoop):
"""Set all keys on provided objects to auto tangent, optionally matching in and out tangents."""
if isinstance(objects, types.StringTypes):
objects = [objects]
if not isinstance(objects, types.ListType) and not isinstance(objects, types.TupleType):
sys.stderr.write("ERROR: Unable to smooth animation curves on object %s. Argument must be a string, list, or tuple of objects or attribute names.\n")
return False
for object in objects:
cmds.selectKey(object)
cmds.keyTangent(itt="spline", ott="spline")
if isLoop: matchInOutTangents(object)
return True
def keyFullRotation(pObjectName, pStartTime, pEndTime, pTangentAttribute):
# Enable key on selected objects
cmds.cutKey(pObjectName, time=(pStartTime, pEndTime), attribute=pTangentAttribute)
# Set keyframes
cmds.setKeyframe(pObjectName, time=pStartTime, attribute=pTangentAttribute, value=0)
cmds.setKeyframe(pObjectName, time=pEndTime, attribute=pTangentAttribute, value=360)
# Set linear tangent
cmds.selectKey(pObjectName, time=(pStartTime, pEndTime), attribute=pTangentAttribute)
cmds.keyTangent(inTangentType='linear', outTangentType='linear')
def make_dof(simplified, name, d):
node = "%s.%s" % (name, d)
cmds.selectKey(node, replace=True, k=True)
cmds.selectKey(node, replace=True, k=True)
if cmds.selectKey(node, replace=True, k=True) == 0:
return
keyframes = simplified[name][d]["keyframes"]
beziers = simplified[name][d]["bez"]
values = get_keyframe_values(name, d, keyframes)
delete_anim(node)
create_keyframes(name, d, keyframes, values)
set_bezier_handles(name, d, beziers, keyframes)
def setKey(insert=True, useSelectedCurves=True):
"""Sets clever keys. Hohoho.
If the mouse is over the graph editor, it keys the attributes selected
there. Otherwise it keys the attributes selected in the channel box. If
the channelBox is closed it will key all the attributes on the selected
node. It attempts to use the "Insert Key" function which makes keys match
the curvature of the surrounding keys whenever possible. Set insert
parameter to false to disable this behavior."""
# Get Attributes
attributes = selectedAttributes.get(detectionType="cursor", useSelectedCurves=useSelectedCurves)
currentFrame = cmd.currentTime(q=1)
# Make extra sure attributes are unique (they should already be)
attributes = list(set(attributes))
if cmd.optionVar(ex="animBlendingOpt") and cmd.optionVar(q="animBlendingOpt") == 0:
# PairBlend creation is disabled. All incomming connections on
# attributes will spit out warnings if we try to key them.
removeConnectedAttributes(attributes)
attrCount = 0
for attr in attributes:
# Test if we can use insert
# canInsert returns 2 if something errored out in it.
insertAttr = insert
canInsert = canInsertKey(attr)
if canInsert != 2:
if not (insert and canInsert):
insertAttr = False
# Key it
try:
performSelect = selectNewKeyframe(attr)
cmd.setKeyframe(attr, i=insertAttr)
attrCount += 1
# Select it if in between selected keys, or if adding
# new keys and the last one was selected.
if performSelect:
cmd.selectKey(attr, add=1, k=1, t=(currentFrame, currentFrame))
except RuntimeError as err:
print err
om.MGlobal.displayError("Could not not set a key on %s." % attr)
if attrCount:
om.MGlobal.displayInfo("Set %d keys." % attrCount)
else:
om.MGlobal.displayInfo("No keys were set.")
def animateLeftWrist(self):
self.currentSelection()
bodyControl = self.selection[0]
#Keyraming X translation
cmds.cutKey(bodyControl , attribute= 'translateX')
cmds.setKeyframe(bodyControl , time = self.startTime , attribute = 'translateX' , value = -2)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.52) , attribute = 'translateX' , value = -2)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*1) , attribute = 'translateX' , value = -2)
cmds.selectKey(bodyControl , time = (self.startTime , self.endTime) , attribute = 'translateY')
cmds.keyTangent( inTangentType = "linear" , outTangentType = "linear")
#Keyraming Y translation
cmds.cutKey(bodyControl , attribute= 'translateY')
cmds.setKeyframe(bodyControl , time = self.startTime , attribute = 'translateY' , value = -3.695)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.52) , attribute = 'translateY' , value = -3.695)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*1) , attribute = 'translateY' , value = -3.695)
cmds.selectKey(bodyControl , time = (self.startTime , self.endTime) , attribute = 'translateY')
cmds.keyTangent( inTangentType = "linear" , outTangentType = "linear")
#Keyraming Z translation
cmds.cutKey(bodyControl , attribute= 'translateZ')
cmds.setKeyframe(bodyControl , time = self.startTime , attribute = 'translateZ' , value = -0.651)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.52) , attribute = 'translateZ' , value = 1.259)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*1) , attribute = 'translateZ' , value = -0.651)
cmds.selectKey(bodyControl , time = (self.startTime , self.endTime) , attribute = 'translateZ')
cmds.keyTangent( inTangentType = "linear" , outTangentType = "linear")
#Deleting any keyframes of rotateX
cmds.cutKey(bodyControl , attribute= 'rotateX')
#Keyraming Y rotation
cmds.cutKey(bodyControl , attribute= 'rotateY')
cmds.setKeyframe(bodyControl , time = self.startTime , attribute = 'rotateY' , value = 16.745)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.52) , attribute = 'rotateY' , value = -40.855)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*1) , attribute = 'rotateY' , value = 16.745)
cmds.selectKey(bodyControl , time = (self.startTime , self.endTime) , attribute = 'rotateY')
cmds.keyTangent( inTangentType = "linear" , outTangentType = "linear")
#Keyraming Z rotation
cmds.cutKey(bodyControl , attribute= 'rotateZ')
cmds.setKeyframe(bodyControl , time = self.startTime , attribute = 'rotateZ' , value = -75.98)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.52) , attribute = 'rotateZ' , value = 0)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*1) , attribute = 'rotateZ' , value = -75.98)
cmds.selectKey(bodyControl , time = (self.startTime , self.endTime) , attribute = 'rotateZ')
cmds.keyTangent( inTangentType = "linear" , outTangentType = "linear")
def animateRightWrist(self):
self.currentSelection()
bodyControl = self.selection[0]
#Keyraming X translation
cmds.cutKey(bodyControl , attribute= 'translateX')
cmds.setKeyframe(bodyControl , time = self.startTime , attribute = 'translateX' , value = -2)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.52) , attribute = 'translateX' , value = -2)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*1) , attribute = 'translateX' , value = -2)
cmds.selectKey(bodyControl , time = (self.startTime , self.endTime) , attribute = 'translateY')
cmds.keyTangent( inTangentType = "linear" , outTangentType = "linear")
#Keyraming Y translation
cmds.cutKey(bodyControl , attribute= 'translateY')
cmds.setKeyframe(bodyControl , time = self.startTime , attribute = 'translateY' , value = -3.692)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.52) , attribute = 'translateY' , value = -3.692)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*1) , attribute = 'translateY' , value = -3.692)
cmds.selectKey(bodyControl , time = (self.startTime , self.endTime) , attribute = 'translateY')
cmds.keyTangent( inTangentType = "linear" , outTangentType = "linear")
#Keyraming Z translation
cmds.cutKey(bodyControl , attribute= 'translateZ')
cmds.setKeyframe(bodyControl , time = self.startTime , attribute = 'translateZ' , value = -1.328)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.52) , attribute = 'translateZ' , value = 0.766)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*1) , attribute = 'translateZ' , value = -1.328)
cmds.selectKey(bodyControl , time = (self.startTime , self.endTime) , attribute = 'translateZ')
cmds.keyTangent( inTangentType = "linear" , outTangentType = "linear")
#Deleting any keyframes of rotateX
cmds.cutKey(bodyControl , attribute= 'rotateX')
#Keyraming Y rotation
cmds.cutKey(bodyControl , attribute= 'rotateY')
cmds.setKeyframe(bodyControl , time = self.startTime , attribute = 'rotateY' , value = 39.6)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.52) , attribute = 'rotateY' , value = 0)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*1) , attribute = 'rotateY' , value = 39.6)
cmds.selectKey(bodyControl , time = (self.startTime , self.endTime) , attribute = 'rotateY')
cmds.keyTangent( inTangentType = "linear" , outTangentType = "linear")
#Keyraming Z rotation
cmds.cutKey(bodyControl , attribute= 'rotateZ')
cmds.setKeyframe(bodyControl , time = self.startTime , attribute = 'rotateZ' , value = -105.923)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.52) , attribute = 'rotateZ' , value = 0)
cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*1) , attribute = 'rotateZ' , value = -105.923)
cmds.selectKey(bodyControl , time = (self.startTime , self.endTime) , attribute = 'rotateZ')
cmds.keyTangent( inTangentType = "linear" , outTangentType = "linear")
def make_move(simplified):
for [maya_dof, data_dof] in [["tx", "rx"], ["ty", "ry"], ["tz", "rz"]]:
node = "root.%s" % maya_dof
cmds.selectKey(node, replace=True, k=True)
cmds.selectKey(node, replace=True, k=True)
if cmds.selectKey(node, replace=True, k=True) == 0:
return
keyframes = simplified["move"][data_dof]["keyframes"]
beziers = simplified["move"][data_dof]["bez"]
values = get_keyframe_values("root", maya_dof, keyframes)
delete_anim(node)
create_keyframes("root", maya_dof, keyframes, values)
set_bezier_handles("root", maya_dof, beziers, keyframes)
def create_fk_setup(self):
"""Creates the FK setup."""
cmds.orientConstraint(self.controls['fan'], self.result_jnts[0], mo=True)
mdl = cmds.shadingNode('multDoubleLinear', asUtility=True)
mdl = cmds.rename(mdl, '%s_%s_MDL' % (self.side, self.modulename))
if self.side == 'R':
cmds.expression(s='%s.input1 = time * (-1);' % mdl, o=mdl, ae=1, uc='all')
else:
cmds.expression(s='%s.input1 = time;' % mdl, o=mdl, ae=1, uc='all')
# END if
cmds.connectAttr('%s.speed' % self.controls['fan'], '%s.input2' % mdl, f=True)
cmds.setDrivenKeyframe('%s.rotate%s' % (self.controls['offset'], self._up_axis), cd='%s.output' % mdl, dv=0, v=0)
cmds.setDrivenKeyframe('%s.rotate%s' % (self.controls['offset'], self._up_axis), cd='%s.output' % mdl, dv=1, v=1)
cmds.keyTangent('%s_rotate%s' % (self.controls['offset'], self._up_axis), itt='linear', ott='linear', f=(0, 1))
cmds.selectKey('%s_rotate%s' % (self.controls['offset'], self._up_axis), add=True, k=True, f=(0, 1))
cmds.setInfinity(pri='cycleRelative', poi='cycleRelative')
def animateHeightControl(self): self.currentSelection() bodyControl = self.selection[0] #Keyraming Y translation cmds.cutKey(bodyControl , attribute= 'translateY') cmds.setKeyframe(bodyControl , time = self.startTime , attribute = 'translateY' , value = self.height) cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.16) , attribute = 'translateY' , value = self.height*2) cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.4) , attribute = 'translateY' , value = -1*self.height/2) cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.52) , attribute = 'translateY' , value = self.height) cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.64) , attribute = 'translateY' , value = self.height*2) cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*0.76) , attribute = 'translateY' , value = self.height/2) cmds.setKeyframe(bodyControl, time = int((self.endTime-self.startTime+1)*1) , attribute = 'translateY' , value = self.height) cmds.selectKey(bodyControl , time = (self.startTime , self.endTime) , attribute = 'translateY') cmds.keyTangent( inTangentType = "linear" , outTangentType = "linear")
def query(self) :
sel = m.ls(sl=True)
if sel is None or len(sel) == 0 : m.error("Nothing selected")
rangemode = self.sourceRangeSelector.currentText() # none, fill, segment, spike, all, selected
if rangemode == 'gap':
if len(sel) < 2:
print "Need to markers to find the gap"
return
s = curve.currentSegmentOrGap( sel[1], datarate.nodeRate(sel[1]) )
if s is None or s[0] != 'gap' :
print "Skipping: " + str(sel[1]) + " (not currently in a gap)"
return
sourceIn, sourceOut = s[1]
else:
sourceIn, sourceOut = assign.getSourceRange( sel[0], rangemode )
m.selectKey( sel[0], t=(sourceIn, sourceOut) )
def addSection(rpm=100, startFrame=1000, totalFrames=110):
'''
used to setup rpm wedge
'''
# BUG: keys dont maintain tangent type when setting keyframe
#
sel = cmds.ls(sl=1)[0]
attr = 'rotateY'
crv = cmds.findKeyframe(sel + '.' + attr, c=True)
#
r = valueChangePerFrame(rpm)
print '________________'
print '_____ for', rpm, 'rpm'
print r, ' x value'
x = r * totalFrames
print x, ' on totalFrames'
cmds.setKeyframe(crv, time=(startFrame, startFrame), value=0, shape=False)
cmds.setKeyframe(crv, time=(startFrame + totalFrames, startFrame + totalFrames), value=x, shape=False)
cmds.selectKey(crv)
cmds.keyframe(animation='keys', relative=1, timeChange=(0 - (totalFrames + 1)))
def expandKeySelection(frames=1):
getCurves = getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
if animCurves:
keysSel = getTarget("keysSel", animCurves, getFrom)
keyTimes = getTarget("keyTimes", animCurves)
# add tail and head keys
for n, loopCurve in enumerate(animCurves):
for key in keysSel[n]:
index = keyTimes[n].index(key)
startIndex = index - frames
endIndex = index + frames
if startIndex < 0:
startIndex = 0
cmds.selectKey(loopCurve, addTo=True, index=(startIndex, endIndex))
def delete_redundant_keys(self):
controls = animMod.get_target("controls", selected=True)
print controls
for control in controls:
print control
attributes = animMod.get_target("attributes", attribute_options = ["keyable"], node=control)
for attribute in attributes:
anim_layers = animMod.get_target("anim_layers", selected=False)
for anim_layer in anim_layers:
anim_curves = animMod.get_target("anim_curves", anim_layer=anim_layer, attribute=attribute, node=control)
for anim_curve in anim_curves:
print anim_curve
redundant_keys = []
keyframes = cmds.keyframe(anim_curve, query=True, timeChange=True)
for previous_frame, current_frame, next_frame in animMod.get_prev_current_next(keyframes):
if previous_frame is None:
previous_frame = current_frame
if next_frame is None:
next_frame = current_frame
break
previous_value = cmds.keyframe(anim_curve, query=True, time=(previous_frame, previous_frame), valueChange=True)
current_value = cmds.keyframe(anim_curve, query=True, time=(current_frame, current_frame), valueChange=True)
next_value = cmds.keyframe(anim_curve, query=True, time=(next_frame, next_frame), valueChange=True)
if previous_value == current_value == next_value:
redundant_keys.append(current_frame)
for frame in redundant_keys:
cmds.selectKey(anim_curve, time=(frame,frame), keyframe=True, remove=True)
cmds.cutKey(animation="keys", clear=True)
def create_moon():
"""
create the moon
"""
n = 'moon'
moon_time_period = 0.0748
cmds.sphere(name=n, axis=[0, 1.0, 0], radius=moon_radius * 0.025)
cmds.setAttr(n + 'Shape.castsShadows', 0)
cmds.setAttr(n + 'Shape.receiveShadows', 0)
cmds.select(n)
create_texture(n)
cmds.circle(radius=0.25, normalY=1, normalZ=0, name=n + '_orbit')
cmds.parent('moon_orbit', 'earth')
cmds.select(n, n + '_orbit')
cmds.pathAnimation(name=n + '_path',
fractionMode=True,
follow=True,
followAxis='x',
upAxis='y',
worldUpType='vector',
worldUpVector=[0, 1, 0],
inverseUp=False,
bank=False,
startTimeU=1,
endTimeU=int(moon_time_period * 10000 / time_period[3] /
2))
cmds.selectKey(clear=True)
cmds.selectKey(n + '_path',
keyframe=True,
time=(1,
int(moon_time_period * 10000 / time_period[3] / 2)))
cmds.keyTangent(inTangentType='linear', outTangentType='linear')
cmds.setInfinity(postInfinite='cycle')
animate_rotation('moon',
int(moon_time_period * 10000 / time_period[3] / 2))
def keyFullRotation(self,
pObjectName,
pStartTime,
pEndTime,
pTargetAttribute,
reverse=False,
isTangent=False):
if reverse == False:
startValue = 0
endValue = 360
else:
startValue = 360
endValue = 0
cmds.cutKey(pObjectName,
time=(pStartTime, pEndTime),
attribute=pTargetAttribute)
cmds.setKeyframe(pObjectName,
time=pStartTime,
attribute=pTargetAttribute,
value=startValue)
cmds.setKeyframe(pObjectName,
time=pEndTime,
attribute=pTargetAttribute,
value=endValue)
cmds.selectKey(pObjectName,
time=(pStartTime, pEndTime),
attribute=pTargetAttribute,
keyframe=True)
cmds.keyTangent(inTangentType='linear', outTangentType='linear')
def select_curves_to_filter(self,frameBased=True):
curves = []
if self.filterAll is True:
self.select_all_curves()
else:
curves = cmds.keyframe(q=True, sl=True, name=True)
if curves is None:
cmds.warning("Error: No keys selected, please select at least 4 keys on a curve and try again.")
return 0
keys_to_filter = []
for curve in curves:
if self.excludeState is True:
if curve in self.excludedCurves:
curves.remove(curve)
continue
keys = cmds.keyframe(curve,q=True, sl=True)
min_key = min(keys)
max_key = max(keys)
if keys is None:
continue
window_length = 0
if frameBased:
window_length = max_key - min_key
else:
window_length - len(keys)
if window_length >= 3:
keys_to_filter.append((curve,min_key,max_key))
elif window_length < 3:
s = str(" Skipping the curve " + curve +" as not enough keys (<4) selected on curve.")
cmds.warning(s)
cmds.select(cl=1)
for curve_keys in (keys_to_filter):
cmds.select(curve_keys[0], add=True)
cmds.selectKey(curve_keys[0], add=True, t=(curve_keys[1],curve_keys[2]))
def keyFullRotation(pObjectName, pStartTime, pEndTime, pTargetAttribute):
"""Create a keyframe rotation animation for the specified object.
Rotates the pObjectName around an axis pTargetAttribute,
between pStartTime and pEndTime.
"""
# Remove any animations within the timerange
cmds.cutKey(pObjectName,
time=(pStartTime, pEndTime),
attribute=pTargetAttribute)
# Sets the target values for start and end points
cmds.setKeyframe(pObjectName,
time=pStartTime,
attribute=pTargetAttribute,
value=0)
cmds.setKeyframe(pObjectName,
time=pEndTime,
attribute=pTargetAttribute,
value=360)
# Ensure the rotation has linear velocity
cmds.selectKey(pObjectName,
time=(pStartTime, pEndTime),
attribute=pTargetAttribute,
keyframe=True)
cmds.keyTangent(inTangentType='linear', outTangentType='linear')
def sweepPipe(circle, pipeCurve):
numberOfCVs = cmds.getAttr('%s.cp' % pipeCurve[0], size=1)
motionPath = cmds.pathAnimation("%s" % circle[0], curve=pipeCurve[0], follow=True, startTimeU=1, endTimeU=numberOfCVs)
cmds.selectKey("%s.uValue" % motionPath)
cmds.keyTangent( itt="linear", ott="linear")
pipeSweep = cmds.snapshot(circle, startTime=1, endTime=numberOfCVs)
return pipeSweep
def set_handle_in(name, dof, time, tangent, weight):
node = "%s.%s" % (name, dof)
cmds.selectKey(node, replace=True, k=True, t=(time,time))
cmds.keyTangent( edit=True
, absolute=True
, inAngle=tangent * 180.0 / m.pi
, inWeight=weight )
def select_objfrom_curve(*args):
if not cmds.keyframe(query=True, selected=True, name=True):
print 'No Curve is selected'
else:
selected_list = cmds.ls(selection=True)
selected_f_curve = cmds.keyframe(query=True, selected=True,
name=True)[0]
selected_connect = cmds.listConnections(selected_f_curve,
plugs=True)[0]
if cmds.nodeType(selected_connect) == 'character':
selected_obj = cmds.listConnections(selected_connect,
type='transform')[0]
else:
selected_att = cmds.listConnections(selected_f_curve,
plugs=True)[0]
selected_obj = selected_att.split(".")[0]
cmds.select(clear=True)
if selected_obj in selected_list:
selected_list.remove(selected_obj)
cmds.select(clear=True)
cmds.select(selected_obj, r=True)
cmds.selectKey(selected_f_curve, add=True)
for o_obj in selected_list:
cmds.select(o_obj, add=True)
else:
cmds.select(selected_obj, r=True)
cmds.selectKey(selected_f_curve, add=True)
def filter_sz(dragControl, x, y, modifiers):
if not cmds.ls(sl=True):
print 'Nothing is selected'
else:
if modifiers == 0:
first_selected = cmds.ls(sl=True)
for i in range(len(first_selected)):
if i == 0:
cmds.selectKey(first_selected[i],
replace=True,
attribute='scaleZ')
else:
cmds.selectKey(first_selected[i],
add=True,
attribute='scaleZ')
elif modifiers == 1:
outline_ed_name = "graphEditor" + dragControl.split(
"|").pop()[len('b_c_sz'):] + 'OutlineEd'
mel.eval('string $outlineed_name = "%s"' % outline_ed_name)
c_sz = cmds.button(dragControl.split("|").pop(), q=1, bgc=True)
if (c_sz == [0.0, 0.0, 0.30000762951094834]):
cmds.button(dragControl.split("|").pop(),
edit=1,
bgc=[0.0, 0.0, 1.0])
mel.eval(
'filterUISelectAttributesCheckbox scaleZ 1 $outlineed_name;'
)
elif (c_sz == [0.0, 0.0, 1.0]):
cmds.button(dragControl.split("|").pop(),
edit=1,
bgc=[0.0, 0.0, 0.3])
mel.eval(
'filterUISelectAttributesCheckbox scaleZ 0 $outlineed_name;'
)
def createDummyKey(objects=None, select=False):
objs = filterNoneObjects(objects)
if len(objs) == 0: objs = getObjsSel()
cmds.setKeyframe(objs, time=(-50000, -50000), insert=False)
if select: cmds.selectKey(objs, replace=True, time=(-50000, -50000))
def gpsTurntable():
# Set up framerange
startTime = cmds.playbackOptions ( query = True, minTime = True )
endTime = cmds.playbackOptions ( query = True, maxTime = True )
# Get current selection
selectionList = cmds.ls (selection = True)
if selectionList:
# Get centre of selection
bbox = cmds.exactWorldBoundingBox()
centre_x = (bbox[0] + bbox[3]) / 2.0
centre_y = (bbox[1] + bbox[4]) / 2.0
centre_z = (bbox[2] + bbox[5]) / 2.0
# Create new group
new_grp = cmds.group(empty=True, name="Turntable_%s_grp#" %selectionList[0])
cmds.move(centre_x, centre_y, centre_z, new_grp)
# Create Turntable camera
new_cam = cmds.camera()
cmds.select (selectionList, r = True)
cmds.viewFit (new_cam[0], allObjects = False)
cmds.parent (new_cam[0], new_grp)
cmds.setKeyframe (new_grp, time = startTime-1, attribute = "rotateY", value=0)
cmds.setKeyframe (new_grp, time = endTime, attribute = "rotateY", value=360)
cmds.selectKey (new_grp, time = (startTime-1, endTime), attribute = "rotateY", keyframe = True)
cmds.keyTangent (inTangentType = "linear", outTangentType = "linear")
cmds.rename ("Turntable_%s_cam#" %selectionList[0])
else:
cmds.warning("Please select one or more objects!")
def change_key_color(onOff):
current_time = cmds.currentTime(q=True)
cmds.selectKey(clear=True)
cmds.selectKey(add=True, keyframe=True, time=(current_time,current_time))
cmds.keyframe(tds=onOff)
if onOff:
mel.eval('timeSliderEditKeys makeKey;')
def convertConnectionAsAnimCurve(node, attr):
separateParentConnection(node, attr)
cons = cmds.listConnections(node + '.' + attr, s=1, d=0, p=1, c=1)
if not cons: return None
attrType = cmds.attributeQuery(attr, node=node, attributeType=1)
if attrType == 'doubleLinear':
animCurveType = 'animCurveUL'
elif attrType == 'doubleAngle':
animCurveType = 'animCurveUA'
else:
animCurveType = 'animCurveUU'
animCurve = cmds.createNode(animCurveType)
cmds.connectAttr(cons[1], animCurve + '.input')
cmds.connectAttr(animCurve + '.output', cons[0], f=1)
cmds.setKeyframe(animCurve, f=-1, v=-1)
cmds.setKeyframe(animCurve, f=-.5, v=-.5)
cmds.setKeyframe(animCurve, f=0, v=0)
cmds.setKeyframe(animCurve, f=.5, v=.5)
cmds.setKeyframe(animCurve, f=1, v=1)
cmds.setAttr(animCurve + ".postInfinity", 1)
cmds.setAttr(animCurve + ".preInfinity", 1)
cmds.selectKey(animCurve)
cmds.keyTangent(itt='spline', ott='spline')
return animCurve
def goToKeyframe(option='next',
roundFrame=False,
selected=False,
selectKeys=False,
searchHierarchy=False):
'''
'''
if option != 'next' and option != 'previous':
OpenMaya.MGlobal.displayWarning(
'Option argument should be "next" or "previous"')
return
if selected and selectKeys:
OpenMaya.MGlobal.displayWarning(
'Cannot use selectKeys flag in conjunction with selected flag.')
selectKeys = False
sel = mc.ls(sl=True)
currentTime = mc.currentTime(query=True)
time = currentTime
if not sel:
if option == 'next':
time += 1
elif option == 'previous':
time -= 1
else:
return
#if nothing is selected, just go to the next or previous keyframe
with utl.SkipUndo():
mc.currentTime(time)
return
keySel = utl.KeySelection()
if searchHierarchy:
#if we're looking through the hierarchy,
keySel.keyedInHierarchy()
else:
#create the keySelection object.
#all the heavy lifting is done in ml_utilities.
if selected and keySel.selectedKeys():
pass
if keySel.visibleInGraphEditor():
pass
if keySel.selectedObjects():
pass
time = keySel.findKeyframe(which=option, roundFrame=roundFrame, loop=True)
if selectKeys:
mc.selectKey(keySel.curves, time=(time, ))
#finally, set the time without adding to the undo queue
with utl.SkipUndo():
mc.currentTime(time, edit=True)
def selectKeys( self, keys ) :
''' select the provided keys in the fcurve editor '''
m.select( self.node )
m.selectKey(clear=True)
for i in keys :
m.selectKey( self.node + '.' + self.attr, t=(i,i), add=True)
def reselect(self, objects=True):
if objects:
if self.selection:
sel = cmds.ls(sl=True)
if sel != self.selection:
cmds.select(self.selection)
if self.pack:
for cr in self.pack:
cmds.selectKey(cr[0], add=True, time=(cr[1][0], cr[1][len(cr[1]) - 1]))
def stepTangents(*args):
selection = cmds.ls(sl=True)
if selection:
cmds.selectKey()
else:
cmds.warning(
'there is no object selected but new keys will be in stepped')
cmds.keyTangent(itt='linear', ott='step')
cmds.keyTangent(g=True, itt='linear', ott='step')
def eulerFilter(self, *args, **kwargs):
try:
curveSel=mc.ls(type="animCurve")
mc.selectKey(curveSel, add=1, k=1)
mel.eval('filterCurve %s;'%" ".join(curveSel))
mel.eval('keyTangent -itt linear -ott linear;')
mc.selectKey(cl=1)
except:
print "can't run euler filter"
def autoTangents(*args):
selection = cmds.ls(sl=True)
if selection:
cmds.selectKey()
else:
cmds.warning(
'there is no object selected but new keys will be in auto')
cmds.keyTangent(itt='auto', ott='auto')
cmds.keyTangent(g=True, itt='auto', ott='auto')
def create_keyframes(name, dof, keyframes, dof_values):
for i in range(len(keyframes)):
cmds.setKeyframe(name, attribute=dof, v=dof_values[i], t=keyframes[i]+1)
# enable differences for weights and tangents of input/output for a keyframe
cmds.selectKey(name, replace=True, k=True)
cmds.keyTangent(e=True, weightedTangents=True)
cmds.keyTangent(weightLock=0)
cmds.keyTangent(lock=0)
def createDummyKey(objects=None, select=False):
objs = filterNoneObjects(objects)
if len(objs) == 0:
objs = getObjsSel()
cmds.setKeyframe(objs, time=(-50000, -50000), insert=False)
if select:
cmds.selectKey(objs, replace=True, time=(-50000, -50000))
def keyRotation(instance_group, min_play, max_play, attr):
""" Prepare key frames according to dialog """
cmds.cutKey(instance_group, time=(min_play, max_play), attribute=attr)
cmds.setKeyframe(instance_group, time=min_play, attribute=attr, value=0)
cmds.setKeyframe(instance_group, time=max_play, attribute=attr, value=360)
cmds.selectKey(instance_group,
time=(min_play, max_play),
attribute=attr,
keyframe=True)
cmds.keyTangent(inTangentType="linear", outTangentType="linear")
def keyFullRotation(pObjectName, pStartTime, pEndTime, pTargetAttribute):
cmds.cutKey(pObjectName, time=(pStartTime, pEndTime), attribute=pTargetAttribute)
cmds.setKeyframe(pObjectName, time=pStartTime, attribute=pTargetAttribute, value=0)
cmds.setKeyframe(pObjectName, time=pEndTime, attribute=pTargetAttribute, value=360)
cmds.selectKey(pObjectName, time=(pStartTime, pEndTime), attribute=pTargetAttribute, keyframe=True)
cmds.keyTangent(inTangentType='linear', outTangentType='linear')
def create_fk_setup(self):
"""Creates the FK setup."""
cmds.setDrivenKeyframe('%s.translateX' % self.fk_jnts[1], cd='%s.length' % self.fk_jnts[0], dv=1, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.fk_jnts[1], cd='%s.length' % self.fk_jnts[0], dv=0, v=0, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.fk_jnts[2], cd='%s.length' % self.fk_jnts[1], dv=1, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.fk_jnts[2], cd='%s.length' % self.fk_jnts[1], dv=0, v=0, itt='linear', ott='linear')
cmds.selectKey('%s_translateX' % self.fk_jnts[1], k=True, f=(1,))
cmds.setInfinity(poi='cycleRelative')
cmds.selectKey('%s_translateX' % self.fk_jnts[2], k=True, f=(1,))
cmds.setInfinity(poi='cycleRelative')
def getRoofLinearCurve( startInput, endInput, minValue, maxValue ):
animCurve = cmds.createNode( 'animCurveUU' )
cmds.setKeyframe( f= startInput, v=minValue )
cmds.setKeyframe( f= endInput, v=maxValue )
cmds.keyTangent( itt='linear', ott='linear' )
cmds.selectKey( animCurve )
cmds.setInfinity( poi='cycle', pri='cycle' )
return animCurve
def polyImagePlane():
camera = None
cameraShape = None
imagePlane = []
tmp = cmds.ls(sl=True, dag=True, type='imagePlane')
if len(tmp) > 0:
imagePlane.append(tmp[0])
camList = cmds.ls(sl=True, dag=True, type="camera")
for camName in camList:
camIP = cmds.listConnections("%s.imagePlane" % camName,
sh=True,
d=True)
if camIP:
imagePlane.append(camIP[0])
imagePlaneList = list(set(imagePlane))
if len(imagePlaneList) == 0:
return False
for imagePlane in imagePlaneList:
conn = [
str(m) for m in cmds.listConnections(
imagePlane, type="camera", shapes=True)
if str(m) == imagePlane.split("->")[0]
]
if len(conn) > 0:
cameraShape = getLongName(conn[0])
camera = cmds.listRelatives(cameraShape, parent=True)[0]
camera = getLongName(camera)
else:
return False
implane, planeShape, polyPlane = createPolyImagePlane(
camera, cameraShape, imagePlane)
cmds.select(implane, replace=True)
cmds.setAttr("%s.overrideLevelOfDetail" % planeShape, 1)
seldp = str(cmds.duplicate(implane, rr=True)[0])
cmds.parent(seldp, w=True)
temp = str(cmds.parentConstraint(implane, seldp, mo=False, w=True)[0])
minT = cmds.playbackOptions(q=True, min=True)
maxT = cmds.playbackOptions(q=True, max=True)
cmds.bakeResults(seldp, sm=False, t=(minT, maxT), mr=True, pok=True)
cmds.delete(temp)
scaleList = ["scaleX", "scaleY", "scaleZ"]
scl = [float(cmds.getAttr(implane + "." + i)) for i in scaleList]
cmds.delete(implane)
if cmds.objExists("|aniGeom"):
cmds.parent(seldp, "|aniGeom")
for sca in scaleList:
cmds.setAttr(seldp + "." + sca, scl[scaleList.index(sca)])
try:
cmds.rename(seldp, "projectionCard")
except:
pass
cmds.selectKey(k=True)
cmds.filterCurve(f="euler")
return True
def SwapAnimation(a, b, optionType):
null = cmds.spaceLocator(name="tempCopyNull")
cmds.select(null, r=True)
cmds.animLayer(GetSelectedLayers()[0], edit=True, addSelectedObjects=True)
if cmds.selectKey(a) > 0:
SendAnimation(a, null, optionType)
if cmds.selectKey(b) > 0:
SendAnimation(b, a, optionType)
if cmds.selectKey(null) > 0:
SendAnimation(null, b, optionType)
cmds.delete(null)
def j_fixAdv3_99_forMaya2016():
'fix advanceSkeleton v3.99 stretch not work in maya2016'
j_drivenKey = {"antiPop":4.990848, "normal":4.878867}
for drv in j_drivenKey: #数值
for pat in ("Arm","Leg"): #arm or leg
for side in ("_R","_L"):
for i in ("antiPop","normal"):
mc.selectKey(("IKdistance" + pat + side +"Shape_"+ i), ot =True, f = (j_drivenKey[drv],))
mc.keyTangent(("IKdistance" + pat + side +"Shape_"+ i), lock = False,)
mc.keyTangent( itt = "clamped",ott = "clamped",)
def animate_rotation(n, period):
"""
animates rotation of an object
"""
cmds.select(n)
cmds.currentTime(1)
cmds.setKeyframe(n, breakdown=False, attribute="rotateY")
cmds.currentTime(period)
cmds.setAttr(n + '.rotateY', 360)
cmds.setKeyframe(n, breakdown=False, attribute="rotateY")
cmds.selectKey(n + '.rotateY')
cmds.keyTangent(inTangentType='linear', outTangentType='linear')
cmds.setInfinity(postInfinite='cycle')
def mirrorKeys(newKeyNode):
'''Mirror keyframe node procedure, in case you need to flip your SDK's.
Also works with ordinary keyframe nodes.
'''
keyType = cmds.ls(newKeyNode, st=True)[1]
try:
cmds.selectKey(clear=True)
except:
pass
# Get the number of keyframes.
numKeys = len(cmds.listAttr(newKeyNode + '.ktv', multi=True)) / 3
# Iterate through each key and multiply the values by -1,
# then set the keyframe value.
for x in range(0, numKeys):
v = cmds.getAttr(newKeyNode + '.keyTimeValue[' + str(x) + ']')
v = [v[0][0], v[0][1] * -1]
if keyType in ('animCurveTU', 'animCurveTA', 'animCurveTL'):
cmds.selectKey(newKeyNode, add=True, k=True, t=(v[0], v[0]))
elif keyType in ('animCurveUU', 'animCurveUA', 'animCurveUL'):
cmds.selectKey(newKeyNode, add=True, k=True, f=(v[0], v[0]))
if keyType in ('animCurveTA', 'animCurveUA'):
cmds.keyframe(animation='keys',
absolute=True,
valueChange=math.degrees(v[1]))
else:
cmds.keyframe(animation='keys', absolute=True, valueChange=v[1])
try:
cmds.selectKey(clear=True)
except:
pass
def smoothAnimCurves(objects, isLoop):
"""Set all keys on provided objects to auto tangent, optionally matching in and out tangents."""
if isinstance(objects, types.StringTypes):
objects = [objects]
if not isinstance(objects, types.ListType) and not isinstance(
objects, types.TupleType):
sys.stderr.write(
"ERROR: Unable to smooth animation curves on object %s. Argument must be a string, list, or tuple of objects or attribute names.\n"
)
return False
for object in objects:
cmds.selectKey(object)
cmds.keyTangent(itt="spline", ott="spline")
if isLoop: matchInOutTangents(object)
return True
def select_all_curves(self):
cmds.select(clear=True)
curves = cmds.ls(typ='animCurve')
if curves is None:
cmds.error("No animation curves are present to select keys from.")
for curve in curves:
if self.excludeState is True:
if curve in self.excludedCurves:
continue
keys = cmds.keyframe(curve,q=True)
if keys is None:
continue
elif len(keys) > 3:
cmds.select(curve,add=True)
cmds.selectKey(curve,add=True)
def key_full_rotation(objectName, start_time, end_time, targetAttr):
cmds.cutKey(objectName, time=(start_time, end_time), attribute=targetAttr)
cmds.setKeyframe(objectName,
time=start_time,
attribute=targetAttr,
value=0)
cmds.setKeyframe(objectName,
time=end_time,
attribute=targetAttr,
value=360)
cmds.selectKey(objectName,
time=(start_time, end_time),
attribute=targetAttr,
keyframe=True)
cmds.keyTangent(inTangentType='linear', outTangentType='linear')
def GreenTickKeys(iAllFrame=0):
oKeyPoseFrames = 'KeyPoseFrames'
aKeyFrames = []
if cmds.objExists(oKeyPoseFrames):
for i in range(cmds.keyframe(oKeyPoseFrames + '.tx', kc=True, q=True)):
aKeyFrames.extend(
cmds.keyframe(oKeyPoseFrames + '.tx', index=(i, i), q=True))
aObjList = [
str(s) for s in cmds.selectionConnection(
'graphEditor1FromOutliner', q=True, object=True) or []
]
#aCurveList = [str(s) for s in cmds.keyframe(q = True, name = True)]
# Store Selected Keys
aSelection = []
for o in aObjList:
aName = cmds.keyframe(o, query=True, name=True)
aKeys = cmds.keyframe(o, sl=True, q=True)
if aName and aKeys:
aSelection.append([str(aName[0]), aKeys])
if cmds.ls(sl=True):
cmds.selectKey(clear=True)
# DO
fTime = cmds.currentTime(q=True)
if fTime in aKeyFrames:
cmds.keyframe(t=(fTime, fTime), tds=True)
# Select Stored keys
if aSelection:
for a in aSelection:
sName = a[0]
for t in a[1]:
cmds.selectKey(sName, t=(t, t), tgl=True)
# Update All Frames red/green.
if iAllFrame:
iIn = int(cmds.playbackOptions(q=True, minTime=True))
iOut = int(cmds.playbackOptions(q=True, maxTime=True))
for i in range(iIn, iOut + 1):
if i in aKeyFrames:
cmds.keyframe(t=(i, i), tds=True)
else:
cmds.keyframe(t=(i, i), tds=False)
def keep_extreme_keys(self):
cmds.undoInfo(openChunk = True)
cut_keys = {}
anim_curves = cmds.keyframe(q = True, sl = True, n = True)
for anim_curve in anim_curves:
selected_keys = cmds.keyframe(anim_curve, q = True, sl = True)
remove_keys = self.get_extreme_frames(anim_curve)
print remove_keys
cut_keys[anim_curve] = [x for x in selected_keys if x not in remove_keys]
for anim_curve in cut_keys:
select_keys = cut_keys[anim_curve]
for frame in select_keys:
cmds.selectKey(anim_curve, time=(frame,frame), keyframe=True)
cmds.cutKey(animation="keys", clear=True)
cmds.undoInfo(closeChunk = True)
def SendAnimation(a, b, optionType):
if cmds.selectKey(a) > 0:
if optionType == option(option.keys):
cmds.cutKey(a, time=(cTime, cTime), option=optionType.__str__())
else:
cmds.copyKey(a, option=optionType.__str__())
cmds.pasteKey(b, option='replaceCompletely')
def MirrorAnimation(item, optionType, scaleMatrix):
attr = [
"translateX", "translateY", "translateZ", "rotateX", "rotateY",
"rotateZ"
]
for idx, a in enumerate(attr):
if cmds.getAttr(item + '.' + a, lock=True) == False:
cmds.select(cl=True)
key = cmds.selectKey(item, attribute=a)
if (key > 0):
if optionType == option(option.keys):
cmds.selectKey(item, time=(cTime, cTime), attribute=a)
else: #"curve"
cmds.selectKey(item, attribute=a)
cmds.scaleKey(valueScale=scaleMatrix[idx], valuePivot=0.0)
cmds.select(item)
def bake(world=0, constraint=0):
if _getTime('rangeSelected'):
range = [_getTime('rangeMin'), _getTime('rangeMax')]
else:
range = [_getTime('playbackMin'), _getTime('playbackMax')]
if world:
sels = mc.ls(sl=1)
selLocs = []
for sel in sels:
loc = mc.spaceLocator(name=sel+'_worldBake_loc')[0]
mc.addAttr(loc, ln='target', dt='string')
mc.setAttr(loc+'.target', sel, type='string')
mc.pointConstraint(sel, loc)
mc.orientConstraint(sel, loc)
mc.scaleConstraint(sel, loc)
selLocs.append(loc)
mc.select(selLocs)
mc.bakeResults(time=(int(range[0]), int(range[1])), sampleBy=1, sm=1)
mc.delete(constraints=1)
if constraint:
for loc in selLocs:
target = mc.getAttr(loc+'.target')
mc.delete(target, channels=1)
if mc.getAttr(target+'.tx', l=1) or mc.getAttr(target+'.ty', l=1) or mc.getAttr(target+'.tz', l=1):
mc.warning('Skipping applying pointConstraint because translate channel is locked.')
pass
else:
mc.pointConstraint(loc, target)
if mc.getAttr(target+'.rx', l=1) or mc.getAttr(target+'.ry', l=1) or mc.getAttr(target+'.rz', l=1):
mc.warning('Skipping applying orientConstraint because rotate channel is locked.')
pass
else:
mc.orientConstraint(loc, target)
if mc.getAttr(target+'.sx', l=1) or mc.getAttr(target+'.sy', l=1) or mc.getAttr(target+'.sz', l=1):
mc.warning('Skipping applying scaleConstraint because scale channel is locked.')
pass
else:
mc.scaleConstraint(loc, target)
else:
mc.selectKey(cl=1)
mc.bakeResults(time=(int(range[0]), int(range[1])), sampleBy=1, sm=1)
def plot():
curves = mc.keyframe(q=1, sl=1, name=1)
if type(curves).__name__ != 'NoneType':
for curve in curves:
indexes = mc.keyframe(curve, q=1, sl=1, iv=1)
if len(indexes) != 1:
startTime = int(mc.keyframe(curve, q=1, tc=1, index=tuple([indexes[0]]))[0])
endTime = int(mc.keyframe(curve, q=1, tc=1, index=tuple([indexes[1]]))[0])
mc.selectKey(cl=1)
for point in range(startTime, endTime):
mc.setKeyframe(curve, insert=1, time=point)
mc.selectKey(curve, time=( (startTime+0.01), (endTime-0.01) ), add=1, k=1)
else:
mc.warning('Only one keyframe is selected for the curve ' + curve + '.')
else:
sels = mc.ls(sl=1)
if sels:
timeSlider = mm.eval('$tmp = $gPlayBackSlider')
if mc.timeControl(timeSlider, q=1, rv=1) == 1:
startTime = int(mc.timeControl(timeSlider, q=1, ra=1)[0])
endTime = int(mc.timeControl(timeSlider, q=1, ra=1)[1])
else:
startTime = int(mc.playbackOptions(q=1, min=1))
endTime = int(mc.playbackOptions(q=1, max=1))
curves = mc.keyframe(q=1, name=1)
for curve in curves:
for point in range(startTime, endTime):
mc.setKeyframe(curve, insert=1, time=point)
mc.selectKey(curve, time=( (startTime+0.01), (endTime-0.01) ), add=1, k=1)
else:
mc.warning('Nothing is selected.')
