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 __init__(self,
name='mlBreakdownDraggerContext',
minValue=None,
maxValue=None,
defaultValue=0,
title = 'Breakdown'):
self.keySel = utl.KeySelection()
if self.keySel.selectedKeys():
pass
elif self.keySel.visibleInGraphEditor():
self.keySel.setKeyframe()
elif self.keySel.keyedChannels():
self.keySel.setKeyframe()
if not self.keySel.curves:
return
utl.Dragger.__init__(self, defaultValue=defaultValue, minValue=minValue, maxValue=maxValue, name=name, title=title)
#setup tangent type
itt,ott = utl.getHoldTangentType()
self.time = dict()
self.value = dict()
self.next = dict()
self.prev = dict()
self.average = dict()
for curve in self.keySel.curves:
if self.keySel.selected:
self.time[curve] = mc.keyframe(curve, query=True, timeChange=True, sl=True)
self.value[curve] = mc.keyframe(curve, query=True, valueChange=True, sl=True)
else:
self.time[curve] = self.keySel.time
self.value[curve] = mc.keyframe(curve, time=self.keySel.time, query=True, valueChange=True)
self.next[curve] = list()
self.prev[curve] = list()
self.average[curve] = list()
for i in self.time[curve]:
next = mc.findKeyframe(curve, time=(i,), which='next')
prev = mc.findKeyframe(curve, time=(i,), which='previous')
n = mc.keyframe(curve, time=(next,), query=True, valueChange=True)[0]
p = mc.keyframe(curve, time=(prev,), query=True, valueChange=True)[0]
self.next[curve].append(n)
self.prev[curve].append(p)
self.average[curve].append((n+p)/2)
#set the tangents on this key, and the next and previous, so they flatten properly
mc.keyTangent(curve, time=(i,), itt=itt, ott=ott)
mc.keyTangent(curve, time=(next,), itt=itt)
mc.keyTangent(curve, time=(prev,), ott=ott)
self.setTool()
self.drawString('Left: Weight Prev/Next, Middle: Weight Average')
OpenMaya.MGlobal.displayWarning('Left: Weight Prev/Next, Middle: Weight Average')
def getAnimRange(self):
try:
startFrame = cmds.findKeyframe("b_M_pelvis_v1_JNT", which="first")
endFrame = cmds.findKeyframe("b_M_pelvis_v1_JNT", which="last")
return startFrame, endFrame
except:
print "No object name b_m_pelvis_v1_JNT was found"
def returnListOfKeyIndices(obj):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Return a list of the time indexes of the keyframes on an object
{currentTime,sceneStart,sceneEnd,rangeStart,rangeEnd}
ARGUMENTS:
nothing
RETURNS:
returnDict(dict)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
initialTimeState = mc.currentTime(q=True)
keyFrames = []
firstKey = mc.findKeyframe(obj,which = 'first')
lastKey = mc.findKeyframe(obj,which = 'last')
keyFrames.append(firstKey)
mc.currentTime(firstKey)
while mc.currentTime(q=True) != lastKey:
keyBuffer = mc.findKeyframe(obj,which = 'next')
keyFrames.append(keyBuffer)
mc.currentTime(keyBuffer)
keyFrames.append(lastKey)
# Put the time back where we found it
mc.currentTime(initialTimeState)
return keyFrames
def tweenKeyFunction(self, percent, *args):
selected = cmds.ls(sl=True)
currentTime = cmds.currentTime(query=True)
if selected:
for obj in selected:
# attributes = cmds.listAttr(obj, k=True)
attributes = self.getKeyable(obj)
for attr in attributes:
query = obj + '.' + attr
currentValue = cmds.getAttr(query, time=currentTime)
nextTime = cmds.findKeyframe(query, which='next')
nextValue = cmds.getAttr(query, time=nextTime)
previousTime = cmds.findKeyframe(query, which='previous')
previousValue = cmds.getAttr(query, time=previousTime)
newValue = (nextValue -
previousValue) * percent + previousValue
try:
cmds.setAttr(query, newValue)
except:
pass
self.updateTweenUI(percent)
def ctrl_l(self):
X = self.getSelection()
self.createInMiddle(
"cmds.spaceLocator( name = 'JR_locator_01', position = (0,0,0) )")
if Cache.locatorList != []:
newLocators = self.getSelection()
#print Cache.locatorList, ' this is the cache list'
#print self.getSelection(), 'this is the locator list'
# automatically bake the locators if more than one has been created, because I would only create more than one if it was necessary for verts of faces.
#parentObject = self.getParent(Cache.locatorList[0] )
parentObject = self.getParent(X)
#print parentObject[0]
start = cmds.findKeyframe(parentObject, which="first")
end = cmds.findKeyframe(parentObject, which="last")
if start == end: # this means there's no keyframes
start = cmds.playbackOptions(q=1, minTime=1)
end = cmds.playbackOptions(q=1, maxTime=1)
print end - start, ' this is end - start value'
print start, ' THIS IS START'
for i in range(int(end - start)):
print i, ' this is the iterator value'
cmds.currentTime(start)
for x in range(len(Cache.locatorList)):
cmds.select(Cache.locatorList[x])
print Cache.locatorList[
x], ' this is the locator list for x'
print newLocators[x], ' this is the new locators for x'
middle = self.getMiddle()
cmds.xform(newLocators[x], t=middle[0])
cmds.setKeyframe(newLocators[x])
#print cache.locatorList[i], ' pared with ...', self.getSelection(i)
start += 1
print 'finished'
else:
print 'not working'
def returnListOfKeyIndices(obj):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Return a list of the time indexes of the keyframes on an object
{currentTime,sceneStart,sceneEnd,rangeStart,rangeEnd}
ARGUMENTS:
nothing
RETURNS:
returnDict(dict)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
initialTimeState = mc.currentTime(q=True)
keyFrames = []
firstKey = mc.findKeyframe(obj,which = 'first')
lastKey = mc.findKeyframe(obj,which = 'last')
keyFrames.append(firstKey)
mc.currentTime(firstKey)
while mc.currentTime(q=True) != lastKey:
keyBuffer = mc.findKeyframe(obj,which = 'next')
keyFrames.append(keyBuffer)
mc.currentTime(keyBuffer)
keyFrames.append(lastKey)
# Put the time back where we found it
mc.currentTime(initialTimeState)
return keyFrames
def __init__(self,
name='mlBreakdownDraggerContext',
minValue=None,
maxValue=None,
defaultValue=0,
title = 'Breakdown'):
self.keySel = utl.KeySelection()
if self.keySel.selectedKeys():
pass
elif self.keySel.visibleInGraphEditor():
self.keySel.setKeyframe()
elif self.keySel.keyedChannels():
self.keySel.setKeyframe()
if not self.keySel.curves:
return
utl.Dragger.__init__(self, defaultValue=defaultValue, minValue=minValue, maxValue=maxValue, name=name, title=title)
#setup tangent type
itt,ott = utl.getHoldTangentType()
self.time = dict()
self.value = dict()
self.next = dict()
self.prev = dict()
self.average = dict()
for curve in self.keySel.curves:
if self.keySel.selected:
self.time[curve] = mc.keyframe(curve, query=True, timeChange=True, sl=True)
self.value[curve] = mc.keyframe(curve, query=True, valueChange=True, sl=True)
else:
self.time[curve] = self.keySel.time
self.value[curve] = mc.keyframe(curve, time=self.keySel.time, query=True, valueChange=True)
self.next[curve] = list()
self.prev[curve] = list()
self.average[curve] = list()
for i in self.time[curve]:
next = mc.findKeyframe(curve, time=(i,), which='next')
prev = mc.findKeyframe(curve, time=(i,), which='previous')
n = mc.keyframe(curve, time=(next,), query=True, valueChange=True)[0]
p = mc.keyframe(curve, time=(prev,), query=True, valueChange=True)[0]
self.next[curve].append(n)
self.prev[curve].append(p)
self.average[curve].append((n+p)/2)
#set the tangents on this key, and the next and previous, so they flatten properly
mc.keyTangent(curve, time=(i,), itt=itt, ott=ott)
mc.keyTangent(curve, time=(next,), itt=itt)
mc.keyTangent(curve, time=(prev,), ott=ott)
self.setTool()
self.drawString('Left: Weight Prev/Next, Middle: Weight Average')
OpenMaya.MGlobal.displayWarning('Left: Weight Prev/Next, Middle: Weight Average')
def ctrl_l (self):
X = self.getSelection()
self.createInMiddle("cmds.spaceLocator( name = 'JR_locator_01', position = (0,0,0) )")
if Cache.locatorList != []:
newLocators = self.getSelection()
#print Cache.locatorList, ' this is the cache list'
#print self.getSelection(), 'this is the locator list'
# automatically bake the locators if more than one has been created, because I would only create more than one if it was necessary for verts of faces.
#parentObject = self.getParent(Cache.locatorList[0] )
parentObject = self.getParent(X)
#print parentObject[0]
start = cmds.findKeyframe( parentObject, which = "first" )
end = cmds.findKeyframe( parentObject, which = "last" )
if start == end: # this means there's no keyframes
start = cmds.playbackOptions(q=1, minTime=1)
end = cmds.playbackOptions(q=1, maxTime=1)
print end-start, ' this is end - start value'
print start, ' THIS IS START'
for i in range(int(end-start)):
print i, ' this is the iterator value'
cmds.currentTime(start)
for x in range(len(Cache.locatorList)):
cmds.select(Cache.locatorList[x])
print Cache.locatorList[x], ' this is the locator list for x'
print newLocators[x], ' this is the new locators for x'
middle = self.getMiddle()
cmds.xform(newLocators[x], t= middle[0])
cmds.setKeyframe(newLocators[x])
#print cache.locatorList[i], ' pared with ...', self.getSelection(i)
start += 1
print 'finished'
else:
print 'not working'
def playblastStart(cameraList): for x in cameraList: i = cmds.listRelatives( x, p=True ) cmds.select(i) start = cmds.findKeyframe( i, which="first" ) end = cmds.findKeyframe( i, which="last" ) sceneNameFull = cmds.file(query = True, shortName = True, sceneName = True) if '.mb' in sceneNameFull or '.ma' in sceneNameFull: sceneName = sceneNameFull[:-3] else: sceneName = sceneNameFull cmds.select(cl = 1) focus = cmds.getPanel( withFocus=True ) cmds.modelPanel( focus, edit=True, camera = x ) cmds.modelEditor( focus, edit = True, cameras = False, locators = False) print start, end if start == end: # this means there's no keyframes print 'no keyframes on this one, playblasting timeline duration' cmds.playblast (format = "qt", compression = "Sorenson Video 3", filename = desktop + sceneName + '_' + str(i[0]) + '.mov', clearCache = 1 , viewer = 0, showOrnaments = 1, fp = 4, percent = 100, quality = 100, widthHeight = [1280, 720]) else: print 'keyframes found, playblasting their start to end' cmds.playblast (startTime = start, endTime = end, format = "qt", compression = "Sorenson Video 3", filename = desktop + sceneName + '_' + str(i[0]) + '.mov', sequenceTime = 0, clearCache = 1 , viewer = 0, showOrnaments = 1, fp = 4, percent = 100, quality = 100, widthHeight = [1280, 720]) #cmds.playblast( completeFilename = str(i) + '.mov', startTime = start, endTime = end, viewer = True, clearCache = True, percent = 100, quality = 100, format = "qt", framePadding = 20 ) cmds.modelEditor( focus, edit = True, cameras = True, locators = True) print ' moving to the next one '
def autoTranfer (self,arg):
self.listSel = mc.ls(selection = True)
if not mc.objExists('ARLoc_Grp'):
mc.group( em=True, name='ARLoc_Grp')
self.bakeLoc = []
self.delPar = []
self.delScale = []
self.selList = []
for self.sel in self.listSel:
#self.locName = self.sel+"_loc"
self.locName = self.sel.replace(':','_')+"_loc" #060117 edit because namespace AD_AR are change
self.loc = mc.spaceLocator(p=(0,0,0),name = self.locName )
self.parentLoc = mc.parentConstraint(self.sel,self.loc,maintainOffset = False)
self.scaleLoc = mc.scaleConstraint(self.sel,self.loc,maintainOffset = False) #
self.bakeLoc.append(self.loc[0]) #because loc is list
self.delPar.append(self.parentLoc[0]) #because delPar is list
self.selList.append(self.sel)
#mc.bakeResults(self.loc,simulation=True,time = (self.timeSliderMin,self.timeSliderMax))
#mc.delete(self.parentLoc)
#mc.cutKey(self.sel, option='keys')
#self.parentCon = mc.parentConstraint(self.loc,self.sel,maintainOffset = True)
#self.scaleCon = mc.scaleConstraint(self.loc,self.sel,maintainOffset = True)
#mc.parent(self.loc,'ARLoc_Grp')
#mc.cutKey(self.loc,time=((self.timeSliderMin+1), (self.timeSliderMax-1)), option='keys')
print self.delPar
self.animNodes = mc.ls (type='animCurve')
self.firstKey = mc.findKeyframe(self.animNodes,which='first')
self.lastKey = mc.findKeyframe(self.animNodes,which='last')
if self.firstKey < 101:
self.firstKey = 101
# isolate viewport for faster baking
mayaTools.isolateObj(True)
# bake locator
mc.bakeResults(self.bakeLoc,simulation=True,time = (self.firstKey,self.lastKey))
# restore viewport back
mayaTools.isolateObj(False)
mc.delete(self.delPar)
mc.delete(self.delScale)
mc.cutKey(self.selList, option='keys')
#return
for self.sel in self.listSel:
#self.locName = self.sel+"_loc"
self.locName = self.sel.replace(':','_')+"_loc" #060117 edit because namespace AD_AR are change
#mc.cutKey(self.sel, option='keys')
self.parentCon = mc.parentConstraint(self.locName,self.sel,maintainOffset = False) #True
self.scaleCon = mc.scaleConstraint(self.locName,self.sel,maintainOffset = False)
mc.parent(self.locName,'ARLoc_Grp')
for shotSq in mc.sequenceManager(listShots = True):
self.currentShotStart = mc.shot( shotSq,q=True,st=True)
self.currentShotEnd = mc.shot (shotSq,q=True,et=True )
mc.cutKey(self.locName,time=((self.currentShotStart+1), (self.currentShotEnd-1)), option='keys')
def GrabKey(*args):
print(mc.findKeyframe(timeSlider=True, which="first"))
print(mc.findKeyframe(timeSlider=True, which="last"))
selection = mc.ls(sl=True)
#print(mc.ls(sl=True))
firstKey = mc.findKeyframe(timeSlider=True, which="first")
lastKey = mc.findKeyframe(timeSlider=True, which="last")
mc.playblast(startTime=firstKey, endTime=lastKey)
def getAnimRange():
try:
startFrame = cmds.findKeyframe("b_M_pelvis_v1_JNT", which="first")
endFrame = cmds.findKeyframe("b_M_pelvis_v1_JNT", which="last")
print startFrame, endFrame
writeArguments(str(startFrame) + ',' + str(endFrame))
return startFrame, endFrame
except:
print "No object name b_M_pelvis_v1_JNT was found"
def weightBreakdownStep(direction='next', weight=0.2):
keySel = utl.KeySelection()
if keySel.selectedKeys():
pass
elif keySel.visibleInGraphEditor():
keySel.setKeyframe()
elif keySel.keyedChannels():
keySel.setKeyframe()
if not keySel.curves:
return
times = list()
values = list()
data = list()
for curve in keySel.curves:
if keySel.selected:
times = mc.keyframe(curve, query=True, timeChange=True, sl=True)
values = mc.keyframe(curve, query=True, valueChange=True, sl=True)
else:
times = [keySel.time]
values = mc.keyframe(curve,
time=keySel.time,
query=True,
valueChange=True)
for i, v in zip(times, values):
nextTime = mc.findKeyframe(curve, time=(i, ), which='next')
n = mc.keyframe(curve,
time=(nextTime, ),
query=True,
valueChange=True)[0]
prevTime = mc.findKeyframe(curve, time=(i, ), which='previous')
p = mc.keyframe(curve,
time=(prevTime, ),
query=True,
valueChange=True)[0]
data.append([curve, i, v, n, p])
for d in data:
value = None
if direction == 'next':
value = d[2] + ((d[3] - d[2]) * weight)
elif direction == 'previous':
value = d[2] + ((d[4] - d[2]) * weight)
elif direction == 'average':
value = d[2] + (((d[3] + d[4]) / 2 - d[2]) * weight)
else:
break
mc.keyframe(d[0], time=(d[1], ), valueChange=value)
def _rangeTimeLine():
firstKey = mc.findKeyframe(timeSlider=True, which='first')
lastKey = mc.findKeyframe(timeSlider=True, which='last')
if firstKey == lastKey:
mc.warning('El control tiene un solo key')
mc.playbackOptions(min=int(firstKey) - 14, max=int(lastKey) + 14)
mc.playbackOptions(animationStartTime=int(firstKey) - 14,
animationEndTime=int(lastKey) + 14)
mc.currentTime(firstKey)
def auto_retarget_export(self):
if self.name_export_root_le.text() == "":
return om.MGlobal.displayError(
"Please write down export root name!")
# Create and check
self.create_directory()
# Get all files path
files_path, maya_files_path = self.get_path_file_mixamo()
if len(maya_files_path) != 1:
om.MGlobal.displayError(
"There is too many or none maya file in the folder")
maya_file = maya_files_path[0]
maya_file_path = maya_file.replace("\\", "/")
cm.file(maya_file_path, force=True, open=True, ignoreVersion=True)
# Loop through all path
for path in files_path:
# Rename path for maya can read
new_path = path.replace("\\", "/")
# Import fbx file into scene with out namespace
cm.file(new_path,
i=True,
mergeNamespacesOnClash=True,
namespace=':')
cm.currentUnit(time='ntsc')
first_key = int(
cm.findKeyframe("Hips", timeSlider=True, which='first'))
last_key = int(cm.findKeyframe("Hips", which='last')) + 1
cm.playbackOptions(animationStartTime=0,
animationEndTime=last_key,
minTime=0,
maxTime=last_key)
# Get fbx file name without the path
fbxName = path.split("/")[-1]
# Set path to new folder export we create
path_fbx = (os.path.join(self.directory,
fbxName)).replace(os.sep, '/')
# Export fbx file
name_export_root = self.name_export_root_le.text()
export_root = pm.PyNode(name_export_root)
pm.select(export_root)
self.export_option(path_fbx)
def tranferKey(self, arg):
self.listSel = mc.ls(selection=True)
if not mc.objExists('ARLoc_Grp'):
mc.group(em=True, name='ARLoc_Grp')
self.bakeLoc = []
self.delPar = []
self.delScale = []
self.selList = []
for self.sel in self.listSel:
self.locName = self.sel + "_loc"
self.loc = mc.spaceLocator(p=(0, 0, 0), name=self.locName)
self.parentLoc = mc.parentConstraint(self.sel,
self.loc,
maintainOffset=False)
self.scaleLoc = mc.scaleConstraint(self.sel,
self.loc,
maintainOffset=False) #
self.bakeLoc.append(self.loc[0]) #because loc is list
self.delPar.append(self.parentLoc[0]) #because delPar is list
self.delScale.append(self.scaleLoc[0])
self.selList.append(self.sel)
print self.delPar
self.animNodes = mc.ls(type='animCurve')
self.firstKey = mc.findKeyframe(self.animNodes, which='first')
self.lastKey = mc.findKeyframe(self.animNodes, which='last')
if self.firstKey < 101:
self.firstKey = 101
# isolate viewport for faster baking
mayaTools.isolateObj(True)
# bake locator
mc.bakeResults(self.bakeLoc,
simulation=True,
time=(self.firstKey, self.lastKey))
# restore viewport back
mayaTools.isolateObj(False)
mc.delete(self.delPar)
mc.delete(self.delScale)
mc.cutKey(self.selList, option='keys')
mm.eval('warning "Delete List Edit and Connect Locator 2/2 ";')
mc.confirmDialog(title='Warning',
message='Remove Assembly List Edit first',
button=['OK'])
def pressProcedure(userInput): global initPlaybackSpeed initPlaybackSpeed = mc.playbackOptions(q=True, playbackSpeed=True) if userInput == True: mc.currentTime(mc.findKeyframe(timeSlider=True, which="next"), edit=True) elif userInput == False: mc.currentTime(mc.findKeyframe(timeSlider=True, which="previous"), edit=True) else: raise QuitException, "# pressProcedure >> Wrong input: " + `userInput`
def pressProcedure(userInput):
global initPlaybackSpeed
initPlaybackSpeed = mc.playbackOptions(q=True, playbackSpeed=True)
if userInput == True:
mc.currentTime(mc.findKeyframe(timeSlider=True, which="next"),
edit=True)
elif userInput == False:
mc.currentTime(mc.findKeyframe(timeSlider=True, which="previous"),
edit=True)
else:
raise QuitException, "# pressProcedure >> Wrong input: " + ` userInput `
def get_animation_range(self):
print 'getting animation range'
if cmds.objExists(self.namespace + ':' + self.master_control):
self.startFrame = cmds.findKeyframe(self.namespace + self.master_control, which='first')
self.endFrame = cmds.findKeyframe(self.namespace + self.master_control, which='last')
# legacy rig
elif cmds.objExists('b_M_pelvis_v1_JNT'):
self.startFrame = cmds.findKeyframe('b_M_pelvis_v1_JNT', which='first')
self.endFrame = cmds.findKeyframe('b_M_pelvis_v1_JNT', which='last')
else:
cmds.error('No object name ' + 'b_M_pelvis_v1_JNT' + ' was found')
cmds.error('No object name ' + self.master_control + ' was found')
def getObjectsWithKeys(self):
keyedObjects = []
for i in self.selection:
startFrame = cmds.findKeyframe(i, which="first")
endFrame = cmds.findKeyframe(i, which="last")
if startFrame == endFrame:
pass
else:
keyedObjects.append(i)
return keyedObjects
def alt_b(self): if self.getSelection() == 'None': cmds.CycleBackgroundColor() # cycles the background color as per the default else: if self.getType(0) == 'face' or self.getType(0) == 'vertex' or self.getType(0) == 'edge': self.bevelTool() # switch this over to recognize the animation category later on istead of just fitting to a camera selection. Should be able to work on any object selected else: start = cmds.findKeyframe( self.getSelection(), which = "first" ) end = cmds.findKeyframe( self.getSelection(), which = "last" ) if start == end: # this means there's no keyframes start = cmds.playbackOptions(q=1, minTime=1) end = cmds.playbackOptions(q=1, maxTime=1) cmds.bakeResults(self.getSelection(), simulation = True, time =(start,end), sampleBy = 1 )
def getKeyframeData(self):
startFrameIndex = []
endFrameIndex = []
for i in self.keyedObjects:
startFrame = cmds.findKeyframe(i, which="first")
endFrame = cmds.findKeyframe(i, which="last")
startFrameIndex.append(startFrame)
endFrameIndex.append(endFrame)
print startFrameIndex
print endFrameIndex
return min(startFrameIndex), max(endFrameIndex)
def Keyframe_Match(MotionPathText,LocText):
MotionPath = cmds.textField(MotionPathText,q=1,tx=1)
Locator = cmds.textField(LocText,q=1,tx=1)
Selection = cmds.ls(sl=1)[0]
cmds.cutKey("%s.uValue"%MotionPath,clear=True)
AnimCurve = cmds.listConnections( "%s.uValue"%Locator, d=False, s=True )[0]
StartTime = cmds.findKeyframe(Locator,w="first")
EndTime = cmds.findKeyframe(Locator,w="last")
cmds.copyKey( "%s.uValue" % Locator, time=(StartTime,EndTime))
cmds.pasteKey("%s.uValue" % MotionPath)
cmds.headsUpMessage(u"关键帧匹配完成")
def putKey(self):
# print self.obj, self.attr, self.frame, self.offset, self.value, '_____________________________'
if cmds.getAttr(self.obj + '.' + self.attr, se=True):
# get curve name, set key
crv = cmds.findKeyframe(self.obj, at=self.attr, c=True)
# print crv, '____crv'
if not crv:
s = cmds.setKeyframe(self.obj, at=self.attr, time=(
self.frame + self.offset, self.frame + self.offset), value=self.value, shape=False, nr=False, mr=True)
self.crv = cmds.findKeyframe(self.obj, at=self.attr, c=True)[0]
# make tangents spline type, if default is 'auto', tangent edit doesn't take on first key in anim curve
cmds.keyTangent(self.crv, edit=True, time=(self.frame + self.offset, self.frame + self.offset),
inTangentType='spline', outTangentType='spline')
else:
self.crv = crv[0]
s = cmds.setKeyframe(self.obj, at=self.attr, time=(
self.frame + self.offset, self.frame + self.offset), value=self.value, shape=False, nr=False, mr=True, i=True)
# apply the rest
if self.crv:
# set curve type, set weights
cmds.keyframe(self.crv, time=(self.frame + self.offset, self.frame +
self.offset), valueChange=self.value) # correction, hacky, (not sure what this is doing)
cmds.setAttr(self.crv + '.weightedTangents', self.weightedTangents)
cmds.keyTangent(self.crv, edit=True, time=(self.frame + self.offset, self.frame + self.offset),
inTangentType=self.inTangentType, outTangentType=self.outTangentType)
if self.inAngle != None:
cmds.keyTangent(self.crv, edit=True, time=(
self.frame + self.offset, self.frame + self.offset), inAngle=self.inAngle)
if self.outAngle != None:
cmds.keyTangent(self.crv, edit=True, time=(
self.frame + self.offset, self.frame + self.offset), outAngle=self.outAngle)
if self.lock == True or self.lock == False:
cmds.keyTangent(self.crv, edit=True, time=(
self.frame + self.offset, self.frame + self.offset), lock=self.lock)
if self.weightedTangents:
cmds.keyTangent(self.crv, edit=True, time=(
self.frame + self.offset, self.frame + self.offset), weightLock=self.weightLock)
if self.inWeight != None:
cmds.keyTangent(self.crv, edit=True, time=(
self.frame + self.offset, self.frame + self.offset), inWeight=self.inWeight)
if self.outWeight != None:
cmds.keyTangent(self.crv, edit=True, time=(
self.frame + self.offset, self.frame + self.offset), outWeight=self.outWeight)
else:
message('Unable to add animation to ' + self.obj + '.' + self.attr)
# pass
if not crv:
pass
def playblastStart(cameraList):
for x in cameraList:
i = cmds.listRelatives(x, p=True)
cmds.select(i)
start = cmds.findKeyframe(i, which="first")
end = cmds.findKeyframe(i, which="last")
sceneNameFull = cmds.file(query=True, shortName=True, sceneName=True)
if '.mb' in sceneNameFull or '.ma' in sceneNameFull:
sceneName = sceneNameFull[:-3]
else:
sceneName = sceneNameFull
cmds.select(cl=1)
focus = cmds.getPanel(withFocus=True)
cmds.modelPanel(focus, edit=True, camera=x)
cmds.modelEditor(focus, edit=True, cameras=False, locators=False)
print start, end
if start == end: # this means there's no keyframes
print 'no keyframes on this one, playblasting timeline duration'
cmds.playblast(format="qt",
compression="Sorenson Video 3",
filename=desktop + sceneName + '_' + str(i[0]) +
'.mov',
clearCache=1,
viewer=0,
showOrnaments=1,
fp=4,
percent=100,
quality=100,
widthHeight=[1280, 720])
else:
print 'keyframes found, playblasting their start to end'
cmds.playblast(startTime=start,
endTime=end,
format="qt",
compression="Sorenson Video 3",
filename=desktop + sceneName + '_' + str(i[0]) +
'.mov',
sequenceTime=0,
clearCache=1,
viewer=0,
showOrnaments=1,
fp=4,
percent=100,
quality=100,
widthHeight=[1280, 720])
#cmds.playblast( completeFilename = str(i) + '.mov', startTime = start, endTime = end, viewer = True, clearCache = True, percent = 100, quality = 100, format = "qt", framePadding = 20 )
cmds.modelEditor(focus, edit=True, cameras=True, locators=True)
print ' moving to the next one '
def HotKey_PreviousKey(): # PrevKey v2.0.1 cmds.undoInfo(swf = 0) cmds.currentTime(cmds.findKeyframe(timeSlider = True, which = 'previous')) GreenTickKeys() cmds.undoInfo(swf = 1) DisplayFaceValues()
def get(self):
#
self.value = cmds.getAttr(self.obj + '.' + self.name)
if not self.poseOnly:
self.crv = cmds.findKeyframe(self.obj, at=self.name, c=True)
if self.auto:
self.getCurve()
def Keyframe_Match(text):
target = cmds.textField(text,q=1,tx=1)
selList = cmds.ls(sl=1)
for sel in selList:
StartTime = cmds.getAttr("%s.start"%sel)
EndTime = cmds.getAttr("%s.end"%sel)
if StartTime == EndTime:
StartTime = cmds.findKeyframe(sel,w="first")
EndTime = cmds.findKeyframe(sel,w="last")
cmds.copyKey( sel, time=(StartTime,EndTime), option="curve" ,at="translate")
targetEndTime = cmds.findKeyframe(target,w="last")
cmds.pasteKey( target, time=(targetEndTime,targetEndTime) )
cmds.headsUpMessage(u"关键帧匹配完成")
def changeRO(obj, ro):
'''
'''
roLst = ['xyz', 'yzx', 'zxy', 'xzy', 'yxz', 'zyx']
if cmds.getAttr(obj + '.rotateOrder', settable=1):
keyframes = getKeyedFrames(obj)
origRO = cmds.getAttr(obj + '.rotateOrder')
if ro != roLst[origRO]:
if keyframes:
cn.uiEnable(controls='modelPanel')
r = getRange()
autoK = cmds.autoKeyframe(q=True, state=True)
cmds.autoKeyframe(state=False)
i = r[0]
current = r[2]
cmds.currentTime(i)
cmds.currentTime(cmds.findKeyframe(which='previous'))
cmds.xform(obj, roo=ro)
for key in keyframes:
cmds.currentTime(key)
cmds.setAttr(obj + '.rotateOrder', origRO)
cmds.xform(obj, roo=ro)
cmds.setKeyframe(obj + '.rotate')
cmds.currentTime(current)
cmds.autoKeyframe(state=autoK)
cn.eulerFilter(obj, tangentFix=True)
cn.uiEnable(controls='modelPanel')
else:
cmds.xform(obj, roo=ro)
# done
message('Rotate order changed: -- ' + roLst[origRO] + ' to ' + ro, maya=True)
else:
message('Rotate order already set -- ' + ro)
else:
message('FAIL. Rotate order is LOCKED or CONNECTED to a custom attribute.', maya=True)
def HotKey_NextKey(): # NextKey v2.0.1 cmds.undoInfo(swf = 0) cmds.currentTime(cmds.findKeyframe(timeSlider = True, which = 'next')) GreenTickKeys() cmds.undoInfo(swf = 1) DisplayFaceValues()
def secondaryChain(offset=0.5, lst='tailSecondary'):
'''
loads selectSet and performs bake and offset of objects
'''
addSel = []
sel = cmds.ls(sl=1)
if sel:
obj = sel[0].split(':')[1]
cmds.select(clear=True)
setDict = ss.loadDict(os.path.join(ss.defaultPath(), lst + '.sel'))
if obj in setDict.values():
# convert set to list of objects
remapped = ss.remapSet(sel[0], setDict)
# print remapped
for con in remapped:
addSel.append(con)
cmds.select(addSel)
# bake to world
locs = sorted(cn.controllerToLocator(matchSet=True))
print locs
print range(len(locs))
for i in range(len(locs)):
animCurves = cmds.findKeyframe(locs[i], c=True)
for crv in animCurves:
cmds.keyframe(crv, relative=1, timeChange=(0 + ((i + 1) * offset)))
else:
message('no selection made')
def camMovementDetector():
shotCam = [cam for cam in cmds.listCameras(perspective = True) if cam != 'persp' if cmds.objExists('%s.type' % cam) if cmds.getAttr('%s.type' % cam) == 'shotCam']
shotCam = shotCam[0] if shotCam else None
animated_curves = []
anim_curves = cmds.findKeyframe(shotCam, curve = True)
if anim_curves:
keyframes_min_max = []
for crv in anim_curves:
keys = cmds.keyframe(crv, valueChange = True, q = True)
frames = cmds.keyframe(crv, timeChange = True, q = True)
keyframes = dict( zip(keys, frames) )
if keyframes:
if len(keyframes) > 1:
start_anim = max( keyframes.values() )
stop_anim = min( keyframes.values() )
keyframes_min_max.append(start_anim) if start_anim not in keyframes_min_max else None
keyframes_min_max.append(stop_anim) if stop_anim not in keyframes_min_max else None
if keyframes_min_max:
return min(keyframes_min_max), max(keyframes_min_max)
def test_paste( self ):
# export some animation
ah = AnimationHandle.create()
ah.set_animation(nt.it.iterDagNodes( nt.api.MFn.kTransform, asNode=0))
filename = ospath.join(tempfile.gettempdir(), "3movin_export.ani.ma")
assert filename == ah.to_file(filename, force=True, type="mayaAscii")
num_nodes=len(list(nt.it.iterDgNodes(asNode=0)))
num_anim=len(list(ah.iter_animation()))
#asure we have some animation
assert num_anim
# just one node - the AnimationHandle dissapears
ah.delete()
assert num_nodes -1 == len(list(nt.it.iterDgNodes(asNode=0)))
# reimport
ahb = AnimationHandle.from_file(filename)[1].next()
# lets get the first keyframes
srcs=list(ahb.iter_animation())
trgt=nt.anim.AnimCurve.findAnimation(nt.it.iterDagNodes( nt.api.MFn.kTransform, asNode=1))
sfirst=cmds.findKeyframe(srcs, which="first")
tfirst=cmds.findKeyframe(trgt, which="first")
length=500
offset=-100
# paste animationdata on nodes with animation
ahb.paste_animation((sfirst, sfirst+length), (sfirst+offset,sfirst+offset+length), option="scaleInsert")
# paste animationdata on nodes without animation
cyl=nt.Node("cylinderStill")
assert len(nt.anim.AnimCurve.findAnimation([cyl])) == 0
ahb.paste_animation((sfirst, sfirst+length), (sfirst,sfirst+length),
option="scaleReplace",
predicate=lambda x, y:"cylinder" in y,
converter=lambda x,y: y.replace("cubeAnimated", "cylinderStill"))
# remove AnimationHandle and check if animation was pasted
ahb.delete()
cylanim=list()
cylanim=nt.anim.AnimCurve.findAnimation([cyl])
assert len(cylanim)
assert sfirst == tfirst
assert cmds.findKeyframe(trgt, which="first") == sfirst+offset
assert cmds.findKeyframe(cylanim, which="first") == sfirst
def set_space_name(node,
space_name,
space_attr="space",
key=True,
keyPrevious=True):
"""Set a node's space by name
set_space_name("lf_tentAEnd_ctl", "master")
"""
enumStr = cmds.attributeQuery(space_attr, node=node, listEnum=True)[0]
enumList = enumStr.split(":")
index = enumList.index(space_name)
curFrame = cmds.currentTime(q=True)
curSpace = cmds.getAttr("{}.{}".format(node, space_attr))
# Get current transform of ctrl
wsPos = cmds.xform(node, query=True, ws=True, t=True)
wsOri = cmds.xform(node, query=True, ws=True, ro=True)
valT = cmds.getAttr(node + '.translate')[0]
valR = cmds.getAttr(node + '.rotate')[0]
# Key previous frame
if key and keyPrevious:
prevKey = cmds.findKeyframe(node + '.' + space_attr,
time=(curFrame, curFrame),
which='previous')
if prevKey != curFrame - 1:
cmds.setKeyframe(node + '.' + space_attr,
time=curFrame - 1,
value=curSpace,
itt='clamped',
ott='step')
for i, attr in enumerate(['tx', 'ty', 'tz']):
cmds.setKeyframe(node + '.' + attr,
time=curFrame - 1,
value=valT[i],
itt='clamped',
ott='step')
for i, attr in enumerate(['rx', 'ry', 'rz']):
cmds.setKeyframe(node + '.' + attr,
time=curFrame - 1,
value=valR[i],
itt='clamped',
ott='step')
cmds.setAttr('%s.%s' % (node, space_attr), index)
# Now that we're in the next space, set the transform back to the previous pos/ori
cmds.xform(node, ws=True, a=True, t=[wsPos[0], wsPos[1], wsPos[2]])
cmds.xform(node, ws=True, a=True, ro=[wsOri[0], wsOri[1], wsOri[2]])
# Key current frame
if key:
for i, attr in enumerate(
[space_attr, 'tx', 'ty', 'tz', 'rx', 'ry', 'rz']):
cmds.setKeyframe(node + '.' + attr, itt='clamped', ott='step')
LOG.info('Set space for "%s" to "%s"...' % (node, space_name))
def feeder(clp, time=1.0):
smaller = []
greater = []
sel = cmds.ls(sl=1)[0]
if sel:
time = cmds.currentTime(q=1)
crvs = cmds.findKeyframe(sel, c=True)
for crv in crvs:
# print crv
frames = cmds.keyframe(crv, q=True)
# print frames
for frame in frames:
if frame < time:
smaller.append(frame)
elif frame > time:
greater.append(frame)
else:
# print frame, time, ' here'
pass
#
sm = smaller[len(smaller) - 1]
y = cmds.keyframe(crv, q=True, time=(sm, sm), valueChange=True, a=True)
y = y[0]
p0 = [sm, y]
#
gr = greater[0]
y = cmds.keyframe(crv, q=True, time=(gr, gr), valueChange=True, a=True)
y = y[0]
p3 = [gr, y]
#
corX, corY = getControlPoints(crv, p0, p3) # only if non-weighted tangents
# print corX, corY
degIn, hlengthIn, value, degOut, hlengthOut = seekPoint(corX, corY, time)
# print degIn, value, degOut, crv
cmds.setKeyframe(crv, time=(time, time), value=value)
cmds.keyTangent(crv, edit=True, time=(time, time), inAngle=degIn, outAngle=degOut)
if cmds.getAttr(crv + '.weightedTangents'):
cmds.keyTangent(crv, edit=True, time=(time, time), inWeight=hlengthIn)
cmds.keyTangent(crv, edit=True, time=(time, time), outWeight=hlengthOut)
# adjust existing tangent weights
o = cmds.keyTangent(crv, q=True, time=(p0[0], p0[0]), outWeight=True)[0]
i = cmds.keyTangent(crv, q=True, time=(p3[0], p3[0]), inWeight=True)[0]
#
gap = p3[0] - p0[0]
#
front = (time - p0[0])
back = (p3[0] - time)
#
front = (time - p0[0]) / gap
back = (p3[0] - time) / gap
#
cmds.keyTangent(crv, edit=True, time=(p0[0], p0[0]), lock=False, outWeight=o * front)
cmds.keyTangent(crv, edit=True, time=(p3[0], p3[0]), lock=False, inWeight=i * back)
cmds.keyTangent(crv, edit=True, time=(p0[0], p0[0]), lock=True)
cmds.keyTangent(crv, edit=True, time=(p3[0], p3[0]), lock=True)
smaller = []
greater = []
else:
print 'Select something'
def weightBreakdownStep(direction='next', weight=0.2):
keySel = utl.KeySelection()
if keySel.selectedKeys():
pass
elif keySel.visibleInGraphEditor():
keySel.setKeyframe()
elif keySel.keyedChannels():
keySel.setKeyframe()
if not keySel.curves:
return
times = list()
values = list()
data = list()
for curve in keySel.curves:
if keySel.selected:
times = mc.keyframe(curve, query=True, timeChange=True, sl=True)
values = mc.keyframe(curve, query=True, valueChange=True, sl=True)
else:
times = [keySel.time]
values = mc.keyframe(curve, time=keySel.time, query=True, valueChange=True)
for i,v in zip(times,values):
nextTime = mc.findKeyframe(curve, time=(i,), which='next')
n = mc.keyframe(curve, time=(nextTime,), query=True, valueChange=True)[0]
prevTime = mc.findKeyframe(curve, time=(i,), which='previous')
p = mc.keyframe(curve, time=(prevTime,), query=True, valueChange=True)[0]
data.append([curve,i,v,n,p])
for d in data:
value = None
if direction == 'next':
value = d[2]+((d[3]-d[2])*weight)
elif direction == 'previous':
value = d[2]+((d[4]-d[2])*weight)
elif direction == 'average':
value = d[2]+(((d[3]+d[4])/2-d[2])*weight)
else: break
mc.keyframe(d[0], time=(d[1],), valueChange=value)
def putCurveAttrs(self):
# need to update curve name, isnt the same as stored, depends on how
# curves and layers are ceated
self.crv = cmds.findKeyframe(self.obj, at=self.name, c=True)
if self.crv:
self.crv = self.crv[0]
cmds.setAttr(self.crv + '.preInfinity', self.preInfinity)
cmds.setAttr(self.crv + '.postInfinity', self.postInfinity)
def delGpuKeys(self, arg):
self.currentFrame = mc.currentTime(query=True)
self.firstKey = int(mc.findKeyframe(which='first'))
self.lastKey = int(mc.findKeyframe(which='last'))
mc.setKeyframe(t=self.currentFrame)
self.bfEnd = self.currentFrame - 1
# self.afSt= self.currentFrame+1
if self.firstKey == self.currentFrame:
mc.cutKey(time=(self.currentFrame, self.lastKey), option='keys')
elif self.lastKey == self.currentFrame:
mc.cutKey(time=(self.firstKey, self.currentFrame), option='keys')
else:
mc.cutKey(time=(self.currentFrame, self.lastKey), option='keys')
mc.cutKey(time=(self.firstKey, self.bfEnd), option='keys')
def getAnimCurves(obj='', attrs=['translateX', 'translateY', 'translateZ', 'rotateX', 'rotateY', 'rotateZ']):
animCurves = cmds.findKeyframe(obj, c=True)
curves = []
for crv in animCurves:
for attr in attrs:
if attr in crv:
curves.append(crv)
return curves
def setPivotValueCurve(self, curve):
timeArray = cmds.keyframe(
curve, q=True, timeChange=True, selected=True)
# per curve pivot value value
if self.pivot == 'left':
pivotTime = float(
cmds.findKeyframe(curve, which='previous', time=timeArray[0]))
self.pivotValue = cmds.keyframe(
curve, q=True, valueChange=True, time=pivotTime)[0]
if self.pivot == 'right':
pivotTime = float(
cmds.findKeyframe(curve, which='next', time=timeArray[-1]))
self.pivotValue = cmds.keyframe(
curve, q=True, valueChange=True, time=pivotTime)[0]
def addKeyOnMaster(ns=''):
fmin = cmds.playbackOptions(q=True, minTime=True)
attrs = ['translateX', 'translateY', 'translateZ', 'rotateX', 'rotateY', 'rotateZ']
for attr in attrs:
crv = cmds.findKeyframe(ns + ':base_startPivot_ctrl.' + attr, c=True)
if crv:
cmds.setKeyframe(crv, i=True, t=(fmin, fmin))
else:
cmds.setKeyframe(ns + ':base_startPivot_ctrl.' + attr, t=(fmin, fmin))
def exportFrameReference(*args):
# get animation start and end points from ui controls
animation_start = cmds.intField('animation_start', query=True, value=True)
animation_end = cmds.intField('animation_end', query=True, value=True)
# prompt user to select file
filename = cmds.fileDialog2(fileMode=0, caption="Export Matrix", okCaption="Export").pop()
# generate zero-filled matrix
matrix = []
for i in range(0, 36):
matrix.append([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
current_frame = animation_start
start_x = -14
start_y = -15
# assumes first frame is a keyframe, prb a bad assumption but nevermind
while current_frame <= animation_end:
# jump to current frame
cmds.currentTime(current_frame, edit=True)
# get locator x and y (actually z) positions
locatorPos = cmds.xform('character_locator', q=1, t=True)
current_tx = locatorPos[0]
current_ty = locatorPos[2]
x = 0 - int(round(start_x - current_tx))
y = 0 - int(round(start_y - current_ty))
# write frame no to correct position in matrix
matrix[y][x] = int(current_frame)
# advance current frame to next keyframe
next_frame = cmds.findKeyframe(timeSlider=True, which='next')
if next_frame > current_frame:
current_frame = next_frame
else:
break
# construct coffeescript matrix from internal one
matrix_output = "["
for line in matrix:
matrix_output += "\n ["
for index, ref in enumerate(line):
if index:
matrix_output += ', '
matrix_output += str(ref)#.zfill(4)
matrix_output += "]"
matrix_output += "\n]"
# write to file
with open(filename, 'w') as export_file:
export_file.write(matrix_output)
def selectNewKeyframe(attr):
'''Determines if a new keyframe should be selected on the given attribute
after being created on the current frame. Returns True if the keyframes
were selected.'''
# Find out the frame number of each selected key
keys = cmd.keyframe(attr, q=1, timeChange=1, sl=1)
if keys:
# Find out the previous/next keys (they will be equal if either
# previous or next frame is missing)
previousKey = cmd.findKeyframe(attr, which='previous')
nextKey = cmd.findKeyframe(attr, which='next')
# If the previous and next keys were selected, we need to select
# the new key.
if previousKey in keys and nextKey in keys:
return True
return False
def navigate(direction):
'''Go to next/prev constraint.'''
sel, constrNames = _getCtrlsFromSelection(PARENT_CONSTRAINT_SUFFIX)
if not constrNames: return
constrNames = [_getParentConstraint(s) for s in constrNames]
if direction > 0:
currentFrame = cmds.currentTime(q=True)
targetFrame = cmds.findKeyframe(constrNames, which='next', t=(currentFrame+0.01, currentFrame+0.01))
else:
targetFrame = cmds.findKeyframe(constrNames, which='previous')
# spostati nella timeline
cmds.currentTime(targetFrame)
# visualizza gli oggetti a cui sono attaccati gli oggetti selezionati
_printParents(constrNames)
def alt_b(self):
if self.getSelection() == 'None':
cmds.CycleBackgroundColor(
) # cycles the background color as per the default
else:
if self.getType(0) == 'face' or self.getType(
0) == 'vertex' or self.getType(0) == 'edge':
self.bevelTool()
# switch this over to recognize the animation category later on istead of just fitting to a camera selection. Should be able to work on any object selected
else:
start = cmds.findKeyframe(self.getSelection(), which="first")
end = cmds.findKeyframe(self.getSelection(), which="last")
if start == end: # this means there's no keyframes
start = cmds.playbackOptions(q=1, minTime=1)
end = cmds.playbackOptions(q=1, maxTime=1)
cmds.bakeResults(self.getSelection(),
simulation=True,
time=(start, end),
sampleBy=1)
def previous_key():
updateVars()
cmds.undoInfo(swf=False)
frame = cmds.findKeyframe(timeSlider=True, which="previous")
# Returns current frame if it can't find a key
if frame == cmds.currentTime(q=True):
cmds.currentTime(min_time, e=1) # Go to the beginning
else:
cmds.currentTime(frame, e=1)
cmds.undoInfo(swf=True)
def next_key():
updateVars()
cmds.undoInfo(swf=False)
frame = cmds.findKeyframe(timeSlider=True, which="next")
# Returns current frame if it can't find a key
if frame == cmds.currentTime(q=True):
cmds.currentTime(max_time, e=1) # Just go to the end
else:
cmds.currentTime(frame, e=1)
cmds.undoInfo(swf=True)
def findKeyframe(*args, **kwargs):
for flag in ['t', 'time']:
try:
rawVal = kwargs[flag]
except KeyError:
continue
else:
kwargs[flag] = _factories.convertTimeValues(rawVal)
res = cmds.findKeyframe(*args, **kwargs)
return res
def matchFunction(self, type, *args):
selected = cmds.ls(sl=True)
currentTime = cmds.currentTime(query=True)
translate = ['translateX', 'translateY', 'translateZ']
rotate = ['rotateX', 'rotateY', 'rotateZ']
translateCheck = cmds.checkBox(self.translateCheck, q=True, v=True)
rotateCheck = cmds.checkBox(self.rotateCheck, q=True, v=True)
for obj in selected:
if translateCheck == True and rotateCheck == False:
attributes = translate
elif rotateCheck == True and translateCheck == False:
attributes = rotate
elif rotateCheck == True and translateCheck == True:
attributes = translate + rotate
else:
attributes = cmds.listAttr(obj, k=True)
for attr in attributes:
querry = obj + '.' + attr
if type == 'previous':
time = cmds.findKeyframe(querry, which='previous')
elif type == 'next':
time = cmds.findKeyframe(querry, which='next')
try:
value = cmds.getAttr(querry, time=time)
cmds.setAttr(querry, value)
except:
pass
def Loc_Match(start,end):
target = "target"
selList = cmds.ls(sl=1)
for sel in selList:
loc = cmds.spaceLocator(n="%s_Driven"%sel)[0]
pnCns = cmds.pointConstraint(sel,loc,mo=0)[0]
StartTime = cmds.intField(start,q=1,v=1)
EndTime = cmds.intField(end,q=1,v=1)
if StartTime == EndTime:
StartTime = cmds.findKeyframe(sel,w="first")
EndTime = cmds.findKeyframe(sel,w="last")
cmds.bakeResults( loc,at="translate", t=(StartTime,EndTime), sb=1 )
cmds.addAttr(loc,ln="start",at="long",k=1)
cmds.addAttr(loc,ln="end",at="long",k=1)
cmds.delete(pnCns)
cmds.headsUpMessage(u"locator生成完毕")
