def getKeyTimes(self, prefKey=None):
prefKey = prefKey or self.prefKey
getFrom = None
keyTimesDict = {}
keyTimes = []
if prefKey in ["selection", "selection_list"]:
animCurves = cmds.keyframe(query=True, name=True)
keyTimes = animMod.getTarget("keyTimes",
animCurves) if animCurves else []
keyTimes = sorted(utilMod.mergeLists(keyTimes))
for n, loopMotionTrail in enumerate(self.nodeInfo.keys()):
keyTimesDict[loopMotionTrail] = keyTimes
else:
for loopMotionTrail in self.nodeInfo.keys():
animCurves = cmds.keyframe(loopMotionTrail,
query=True,
name=True)
keyTimes = animMod.getTarget("keyTimes",
animCurves) if animCurves else []
keyTimesDict[loopMotionTrail] = utilMod.mergeLists(keyTimes)
return keyTimesDict
def spaceSwitch(self, args, all=False, mode="token"):
cmds.refresh(suspend=True)
if mode == "token": switch = self.spaceSwitchToken
elif mode == "custom": switch = self.spaceSwitchCustom
objects = args[0]
attr = args[1]
currSel = cmds.ls(selection=True)
currFrame = cmds.currentTime(query=True)
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
if animCurves:
if all:
keysSel = animMod.getTarget("keyTimes", animCurves, getFrom)
else:
keysSel = animMod.getTarget("keysSel", animCurves, getFrom)
keysSel = utilMod.mergeLists(keysSel)
if keysSel == []:
keysSel = [currFrame]
else:
keysSel = [currFrame]
frames = keysSel
for loopObj in currSel:
if loopObj not in objects: continue
if not cmds.objExists("%s.%s" % (loopObj, attr)): continue
animMod.createDummyKey([loopObj])
getCurves = animMod.getAnimCurves(True)
animCurves = getCurves[0]
animMod.deleteDummyKey([loopObj])
for loopFrame in frames:
cmds.currentTime(loopFrame)
matrix = cmds.xform(loopObj, query=True, ws=True, matrix=True)
rotation = cmds.xform(loopObj,
query=True,
ws=True,
rotation=True)
switch(loopObj, args)
cmds.xform(loopObj, ws=True, matrix=matrix)
cmds.xform(loopObj, ws=True, rotation=rotation)
animMod.eulerFilterCurve(animCurves)
cmds.currentTime(currFrame)
cmds.refresh(suspend=False)
def selectOnlyKeyedObjects():
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
if animCurves:
keysSel = animMod.getTarget("keysSel", animCurves, getFrom)
objects = animMod.getTarget("", animCurves, getFrom)[0]
selObjs = []
for n, loopObj in enumerate(objects):
if len(keysSel[n]) > 0:
if not loopObj in selObjs:
selObjs.append(loopObj)
if len(selObjs) > 0: cmds.select(selObjs, replace=True)
def alignSelection(self, translate=True, rotate=True, all=False):
selection = cmds.ls(selection=True)
if len(selection) < 2:
cmds.warning("You need to select at least 2 objects.")
return
sourceObjs = selection[0:-1]
targetObj = selection[-1]
frames = None
currFrame = cmds.currentTime(query=True)
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
showProgress = all
if animCurves:
if all:
keysSel = animMod.getTarget("keyTimes", animCurves, getFrom)
else:
keysSel = animMod.getTarget("keysSel", animCurves, getFrom)
frames = utilMod.mergeLists(keysSel)
if frames == []:
frames = [currFrame]
else:
frames = [currFrame]
self.align(sourceObjs,
targetObj,
frames,
translate,
rotate,
showProgress,
selectSorceObjs=True)
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 updateCurrentValues(self, animCurves=None, *args):
cmds.undoInfo(stateWithoutFlush=False)
self.removeMessages()
if not animCurves:
animCurves = utilMod.getAllAnimCurves(selection=True)
if not animCurves: return
for loopCurve in animCurves:
#if loopCurve in self.allAnimCurves:
self.currentValues[loopCurve] = self.getCurrentValues(
[loopCurve])["keyValues"][0]
self.allValues[loopCurve] = animMod.getTarget(
"keyValues", [loopCurve])[0]
self.addAnimMessages()
cmds.undoInfo(stateWithoutFlush=True)
def applyTickColor(self, special=True, *args):
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
keysSel = animMod.getTarget("keysSel", animCurves, getFrom)
if animCurves:
for n, loopCurve in enumerate(animCurves):
time = [(loopTime, loopTime) for loopTime in keysSel[n]]
for loopTime in time:
#keycolor
cmds.keyframe(loopCurve,
edit=True,
time=loopTime,
tickDrawSpecial=special)
def getRange(self):
animCurves = cmds.keyframe(query=True, name=True, selected=True)
if animCurves:
keysSel = animMod.getTarget("keysSel", animCurves, "graphEditor")
keysSel = utilMod.mergeLists(keysSel)
range = [min(keysSel), max(keysSel)]
else:
G.playBackSliderPython = G.playBackSliderPython or mel.eval(
'$aTools_playBackSliderPython=$gPlayBackSlider')
range = cmds.timeControl(G.playBackSliderPython,
query=True,
rangeArray=True)
range[1] -= 1
return range
def cropTimelineAnimation():
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
range = animMod.getTimelineRange()
if animCurves:
keyTimes = animMod.getTarget("keyTimes", animCurves, getFrom)
for n, aCurve in enumerate(animCurves):
firstKey = keyTimes[n][0]
lastKey = keyTimes[n][-1]
if range[0] >= firstKey:
cmds.cutKey(aCurve, time=(firstKey, range[0] - 1), clear=True)
if range[1] <= lastKey:
cmds.cutKey(aCurve, time=(range[1], lastKey), clear=True)
def setTween(self, percent, *args):
#utilMod.timer("s")
G.TM_lastTweenCommand = "self.setTween(%s)" % percent
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
if animCurves:
status = "aTools - Tween Machine..."
utilMod.startProgressBar(status)
totalSteps = len(animCurves)
firstStep = 0
thisStep = 0
estimatedTime = None
startChrono = None
cmds.waitCursor(state=True)
cmds.refresh(suspend=True)
keysSel = animMod.getTarget("keysSel", animCurves, getFrom)
keyTimes = animMod.getTarget("keyTimes", animCurves)
timelineTime = None
#keysSelMerged = utilMod.mergeLists(keysSel)
# reverse order to get ease in and out smoothly
if 0 < percent <= 50 or percent == 100:
for loopVal in keysSel:
loopVal.reverse()
#utilMod.timer()
"""
if len(keysSelMerged) == 0:
if not timelineTime: timelineTime = [animMod.getTimelineTime()]
cmds.setKeyframe(animCurves, time=timelineTime[0])
elif len(keysSelMerged) == 1:
cmds.setKeyframe(animCurves, time=keysSelMerged[0])
"""
for thisStep, loopCurve in enumerate(animCurves):
if cmds.progressBar(G.progBar, query=True, isCancelled=True):
utilMod.setProgressBar(endProgress=True)
break
startChrono = utilMod.chronoStart(startChrono, firstStep,
thisStep, totalSteps,
estimatedTime, status)
if not keysSel[thisStep]:
if not timelineTime:
timelineTime = [animMod.getTimelineTime()]
time = timelineTime
else:
time = [(loopTime, loopTime)
for loopTime in keysSel[thisStep]]
# if all keys selected, use timeline time instead
if len(time) == len(keyTimes[thisStep]):
if not timelineTime:
timelineTime = [animMod.getTimelineTime()]
time = timelineTime
for loopTime in time:
prevKeyTime = cmds.findKeyframe(loopCurve,
time=loopTime,
which="previous")
nextKeyTime = cmds.findKeyframe(loopCurve,
time=loopTime,
which="next")
if prevKeyTime == nextKeyTime and prevKeyTime != loopTime[
0] and percent != "linear_next" and percent != "linear_prev": # if there is no previous or next key and at least one key
cmds.setKeyframe(loopCurve, time=loopTime)
elif prevKeyTime != time[0]:
if percent == "linear_prev":
prevKeyTime = nextKeyTime
nextKeyTime = cmds.findKeyframe(loopCurve,
time=(prevKeyTime,
prevKeyTime),
which="next")
prevKeyVal = cmds.keyframe(loopCurve,
query=True,
time=(prevKeyTime,
prevKeyTime),
valueChange=True)[0]
nextKeyVal = cmds.keyframe(loopCurve,
query=True,
time=(nextKeyTime,
nextKeyTime),
valueChange=True)[0]
if nextKeyTime == prevKeyTime:
value = prevKeyVal
else:
value = prevKeyVal + (
(nextKeyVal - prevKeyVal) /
(nextKeyTime - prevKeyTime) *
(loopTime[0] - prevKeyTime))
elif percent == "linear_next":
nextKeyTime = prevKeyTime
prevKeyTime = cmds.findKeyframe(loopCurve,
time=(nextKeyTime,
nextKeyTime),
which="previous")
prevKeyVal = cmds.keyframe(loopCurve,
query=True,
time=(prevKeyTime,
prevKeyTime),
valueChange=True)[0]
nextKeyVal = cmds.keyframe(loopCurve,
query=True,
time=(nextKeyTime,
nextKeyTime),
valueChange=True)[0]
if nextKeyTime == prevKeyTime:
value = prevKeyVal
else:
value = prevKeyVal + (
(nextKeyVal - prevKeyVal) /
(nextKeyTime - prevKeyTime) *
(loopTime[0] - prevKeyTime))
else:
animMod.eulerFilterCurve([loopCurve])
prevKeyVal = cmds.keyframe(loopCurve,
query=True,
time=(prevKeyTime,
prevKeyTime),
valueChange=True)[0]
nextKeyVal = cmds.keyframe(loopCurve,
query=True,
time=(nextKeyTime,
nextKeyTime),
valueChange=True)[0]
#print "prevKeyVal", prevKeyVal, nextKeyVal
#if prevKeyVal == nextKeyVal:
#if not time[0] in keysSel[thisStep]: cmds.setKeyframe(loopCurve, time=loopTime)
#continue
if percent == "linear":
value = prevKeyVal + (
(nextKeyVal - prevKeyVal) /
(nextKeyTime - prevKeyTime) *
(loopTime[0] - prevKeyTime))
else:
value = ((nextKeyVal - prevKeyVal) / 100. *
percent) + prevKeyVal
tangentType = cmds.keyTangent(loopCurve,
query=True,
outTangentType=True,
time=(prevKeyTime,
prevKeyTime))[0]
inTangentType = tangentType.replace("fixed",
"auto").replace(
"step", "auto")
outTangentType = tangentType.replace("fixed", "auto")
if not time[0] in keysSel[thisStep]:
cmds.setKeyframe(loopCurve, time=loopTime)
cmds.keyframe(loopCurve,
edit=True,
time=loopTime,
valueChange=value)
cmds.keyTangent(loopCurve,
edit=True,
time=loopTime,
inTangentType=inTangentType,
outTangentType=outTangentType)
#keycolor
if 1 <= percent <= 99 or percent == "linear":
cmds.keyframe(
loopCurve,
edit=True,
time=loopTime,
tickDrawSpecial=self.getColoredKeys())
if getFrom == "graphEditor":
#curvesToSelect.append([loopCurve, loopTime])
cmds.selectKey(loopCurve, addTo=True, time=loopTime)
estimatedTime = utilMod.chronoEnd(startChrono, firstStep,
thisStep, totalSteps)
#utilMod.timer()
"""
#APPLY
if len(curvesToKey) > 0: cmds.setKeyframe(curvesToKey)
for loopVar in curvesToValue:
cmds.keyframe(loopVar[0], edit=True, time=loopVar[1], valueChange=loopVar[2])
cmds.keyTangent(loopVar[0], edit=True, time=loopVar[1], inTangentType=loopVar[3], outTangentType=loopVar[4])
for loopVar in curvesToColor: cmds.keyframe(loopVar[0], edit=True, time=loopVar[1], tickDrawSpecial=self.getColoredKeys())
for loopVar in curvesToSelect: cmds.selectKey(loopVar[0], addTo=True, time=loopVar[1])
"""
cmds.refresh(suspend=False)
cmds.waitCursor(state=False)
utilMod.setProgressBar(endProgress=True)
def create(self, *args):
img = cmds.iconTextButton("TempCustomPivotBtn", query=True, image=True)
onOff = (img[-10:-4] == "active")
if onOff:
self.clear()
cmds.select(self.sel)
return
cmds.undoInfo(openChunk=True)
cmds.undoInfo(closeChunk=True)
cmds.undoInfo(openChunk=True)
cmds.undoInfo(closeChunk=True)
cmds.undoInfo(openChunk=True)
cmds.undoInfo(closeChunk=True)
cmds.undoInfo(openChunk=True)
self.clear()
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
if animCurves:
keyTimes = animMod.getTarget("keyTimes", animCurves, getFrom)
self.sel = cmds.ls(selection=True)
if not self.sel: return
cmds.iconTextButton(
"TempCustomPivotBtn",
edit=True,
image=uiMod.getImagePath(
"specialTools_create_temp_custom_pivot_active"),
highlightImage=uiMod.getImagePath(
"specialTools_create_temp_custom_pivot_active"))
targetObj = self.sel[-1]
aToolsMod.saveInfoWithScene(self.STORE_NODE, self.CTRLS, self.sel)
currentFrame = cmds.currentTime(query=True)
aToolsMod.saveInfoWithScene(self.STORE_NODE, self.CURRENTFRAME,
currentFrame)
locators = []
for loopSel in self.sel:
nameSpace = utilMod.getNameSpace([loopSel])
loopSelName = "%s_%s" % (nameSpace[0][0], nameSpace[1][0])
locatorName = "tempCustomPivot_%s" % loopSelName
locator = animMod.createNull(locatorName)
locators.append(locator)
G.aToolsBar.align.align([locator], loopSel)
locatorGroup = "tempCustomPivot_group"
animMod.group(name=locatorGroup)
G.aToolsBar.align.align([locatorGroup], targetObj)
with G.aToolsBar.createAToolsNode:
cmds.parent(locators, locatorGroup)
cmds.select(locatorGroup, replace=True)
locators.append(locatorGroup)
aToolsMod.saveInfoWithScene(self.STORE_NODE, self.LOCATORS, locators)
#parent ctrls to locator
constraints = [
"%s_tempCustomPivot_constraint" % loopConstraint
for loopConstraint in self.sel
]
aToolsMod.saveInfoWithScene(self.STORE_NODE, self.CONSTRAINTS,
constraints)
for n, loopSel in enumerate(self.sel):
with G.aToolsBar.createAToolsNode:
cmds.parentConstraint(locators[n],
loopSel,
name=constraints[n],
maintainOffset=True)
constraintNode = "%s.blendParent1" % loopSel
if not cmds.objExists(constraintNode): continue
cmds.setKeyframe(constraintNode)
if keyTimes:
for loopTime in keyTimes[0]:
cmds.setKeyframe("%s.tx" % locatorGroup,
time=(loopTime, loopTime))
if loopTime != currentFrame:
cmds.setKeyframe(constraintNode,
time=(loopTime, loopTime),
value=0)
#enter edit mode
cmds.setToolTo(cmds.currentCtx())
cmds.ctxEditMode()
#scriptjob
cmds.scriptJob(runOnce=True,
killWithScene=True,
event=('SelectionChanged',
self.scriptJob_SelectionChanged))
def setTangent(self,
tangentType,
tangentInOut="inOut",
targetKeys="selected",
*args):
#utilMod.timer(mode="s", function="MAIN FUNCTION")
cmds.waitCursor(state=True)
"""
cmds.undoInfo(openChunk=True)
cmds.undoInfo(closeChunk=True)
cmds.undoInfo(openChunk=True)
cmds.undoInfo(closeChunk=True)
cmds.undoInfo(openChunk=True)
cmds.undoInfo(closeChunk=True)
cmds.undoInfo(openChunk=True)
"""
#tangentType = flow, bounce, auto, etc
#targetKeys = all, selected
#tangentInOut = inOut, in, out
#set default tangent type
if tangentType == "flow":
cmds.keyTangent(edit=True,
g=True,
inTangentType="auto",
outTangentType="auto")
elif tangentType == "step":
cmds.keyTangent(edit=True, g=True, outTangentType=tangentType)
elif tangentType != "bounce":
cmds.keyTangent(edit=True,
g=True,
inTangentType=tangentType,
outTangentType=tangentType)
# get target curves
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
#if there is no curves, exit
if animCurves:
status = "aTools - Tangents..."
utilMod.startProgressBar(status)
totalSteps = len(animCurves)
firstStep = 0
thisStep = 0
estimatedTime = None
startChrono = None
index = None
time = None
if targetKeys == "all": # apply for all keys
time = (-50000, 500000)
if not self.isDefaultTangent(tangentType):
index = animMod.getTarget("keyIndexTimes", animCurves,
getFrom)
self.applyTangent(animCurves, tangentType, getFrom, time,
index)
elif targetKeys == "selected": #apply on a range
if getFrom == "timeline":
time = animMod.getTimelineRange()
time = (time[0], time[1]) #flow and bounce
if not self.isDefaultTangent(tangentType):
index = animMod.getTarget("keysIndexSel", animCurves,
getFrom)
self.applyTangent(animCurves, tangentType, getFrom, time,
index, tangentInOut)
else:
if self.isDefaultTangent(
tangentType
): # if the tangent types are default maya types
#apply individually on each key
keysSel = animMod.getTarget("keysSel", animCurves,
getFrom)
for thisStep, aCurve in enumerate(animCurves):
if cmds.progressBar(G.progBar,
query=True,
isCancelled=True):
utilMod.setProgressBar(endProgress=True)
break
startChrono = utilMod.chronoStart(
startChrono, firstStep, thisStep, totalSteps,
estimatedTime, status)
for loopKey in keysSel[thisStep]:
time = (loopKey, loopKey)
self.applyTangent(aCurve, tangentType, getFrom,
time, index, tangentInOut)
estimatedTime = utilMod.chronoEnd(
startChrono, firstStep, thisStep, totalSteps)
else: #flow and bounce
index = animMod.getTarget("keysIndexSel", animCurves,
getFrom)
self.applyTangent(animCurves, tangentType, getFrom,
time, index, tangentInOut)
else: # first and last frame
keyTimes = animMod.getTarget("keyTimes", animCurves, getFrom)
keyIndexTimes = animMod.getTarget("keyIndexTimes", animCurves,
getFrom)
self.bounceEnds(animCurves, tangentType, getFrom, tangentInOut,
keyTimes, keyIndexTimes, targetKeys)
utilMod.setProgressBar(endProgress=True)
#cmds.undoInfo(closeChunk=True)
cmds.waitCursor(state=False)
def align(self,
sourceObjs,
targetObj,
frames=None,
translate=True,
rotate=True,
showProgress=False,
selectSorceObjs=False):
if not sourceObjs or not targetObj: return
cmds.refresh(suspend=True)
currFrame = cmds.currentTime(query=True)
constraints = []
setValues = []
modes = []
status = "aTools - Aligning nodes..."
if translate:
modes.append({"mode": "translate", "constrain": "pointConstraint"})
if rotate:
modes.append({"mode": "rotate", "constrain": "orientConstraint"})
if showProgress: utilMod.startProgressBar(status)
if not frames:
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
if animCurves:
keysSel = animMod.getTarget("keysSel", animCurves, getFrom)
frames = utilMod.mergeLists(keysSel)
if frames == []:
frames = [currFrame]
else:
frames = [currFrame]
if showProgress:
totalSteps = len(sourceObjs + frames)
firstStep = 0
thisStep = 0
estimatedTime = None
startChrono = None
#get values
for thisStep, loopSourceObj in enumerate(sourceObjs):
if showProgress:
startChrono = utilMod.chronoStart(startChrono, firstStep,
thisStep, totalSteps,
estimatedTime, status)
setValues.append({"modes": [], "values": [], "skips": []})
for loopMode in modes:
mode = loopMode["mode"]
constrainType = loopMode["constrain"]
allAttrs = cmds.listAttr(loopSourceObj,
settable=True,
keyable=True)
skip = [
loopXyz for loopXyz in ["x", "y", "z"]
if "%s%s" % (mode, loopXyz.upper()) not in allAttrs
]
contrainFn = eval("cmds.%s" % constrainType)
with G.aToolsBar.createAToolsNode:
constraints.append(
contrainFn(targetObj, loopSourceObj, skip=skip)[0])
setValues[-1]["modes"].append(mode)
setValues[-1]["values"].append([
cmds.getAttr("%s.%s" % (loopSourceObj, mode),
time=loopKey)[0] for loopKey in frames
])
setValues[-1]["skips"].append(skip)
if showProgress:
estimatedTime = utilMod.chronoEnd(startChrono, firstStep,
thisStep, totalSteps)
#del constraints
for loopConstrain in constraints:
cmds.delete(loopConstrain)
for n, loopKey in enumerate(frames):
if showProgress:
thisStep = thisStep + n + 1
startChrono = utilMod.chronoStart(startChrono, firstStep,
thisStep, totalSteps,
estimatedTime, status)
for nn, loopSourceObj in enumerate(sourceObjs):
loopSetValue = setValues[nn]
values = loopSetValue["values"]
skips = loopSetValue["skips"]
for nnn, loopMode in enumerate(modes):
mode = loopMode["mode"]
xyz = [
loopXyz for loopXyz in ["x", "y", "z"]
if loopXyz not in skips[nnn]
]
for nnnn, loopXyz in enumerate(xyz):
attr = "%s%s" % (mode, loopXyz.upper())
value = values[nnn][n][nnnn]
if len(frames) > 1:
cmds.setKeyframe(loopSourceObj,
attribute=attr,
time=(loopKey, loopKey),
value=value)
if currFrame == loopKey:
cmds.setAttr("%s.%s" % (loopSourceObj, attr),
value)
#euler filter
if n == len(frames) - 1 and rotate:
animCurves = utilMod.mergeLists([
cmds.keyframe(loopSourceObj, query=True, name=True)
for loopSourceObj in sourceObjs
])
animMod.eulerFilterCurve(animCurves)
if showProgress:
estimatedTime = utilMod.chronoEnd(startChrono, firstStep,
thisStep, totalSteps)
if showProgress: utilMod.setProgressBar(endProgress=True)
if selectSorceObjs: cmds.select(sourceObjs)
cmds.refresh(suspend=False)
def smartSnapKeys():
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
if not animCurves or len(animCurves) == 0: return
getFrom = getCurves[1]
keyTimes = animMod.getTarget("keyTimes", animCurves, getFrom)
keysSel = animMod.getTarget("keysSel", animCurves, getFrom)
hasDecimalKeys = False
for loopKey in utilMod.mergeLists(keysSel):
if loopKey != round(loopKey) > 0:
hasDecimalKeys = True
break
if not hasDecimalKeys: return
keyTangentsType = animMod.getTarget("keyTangentsType", animCurves, getFrom)
firstStep = 0
totalSteps = len(animCurves)
estimatedTime = None
status = "aTools - Smart Snap Curves..."
startChrono = None
utilMod.startProgressBar(status)
for thisStep, loopCurve in enumerate(animCurves):
startChrono = utilMod.chronoStart(startChrono, firstStep, thisStep,
totalSteps, estimatedTime, status)
if None in [keyTimes[thisStep], keysSel[thisStep]]: continue
stepKeys = [
loopKey for nn, loopKey in enumerate(keyTimes[thisStep])
if loopKey != round(loopKey) and loopKey in keysSel[thisStep]
and keyTangentsType[thisStep][nn][1] == "step"
]
linearKeys = [
loopKey for nn, loopKey in enumerate(keyTimes[thisStep])
if loopKey != round(loopKey) and loopKey in keysSel[thisStep]
and keyTangentsType[thisStep][nn][1] == "linear"
]
decimalKeys = [
loopKey for nn, loopKey in enumerate(keyTimes[thisStep])
if loopKey != round(loopKey) and loopKey in keysSel[thisStep]
and loopKey not in stepKeys + linearKeys
]
for loopKey in stepKeys:
cmds.snapKey(loopCurve, time=(loopKey, loopKey))
for loopKey in linearKeys:
cmds.snapKey(loopCurve, time=(loopKey, loopKey))
if len(decimalKeys) == 0: continue
if not getFrom:
if cmds.keyframe(query=True, selected=True) != None:
getFrom = "graphEditor"
#inLinearKeys = [round(loopKey) for nn, loopKey in enumerate(keyTimes[thisStep]) if keyTangentsType[thisStep][nn][0] == "linear"]
#outLinearKeys = [round(loopKey) for nn, loopKey in enumerate(keyTimes[thisStep]) if keyTangentsType[thisStep][nn][1] == "linear"]
createKeys = list(set([round(loopKey) for loopKey in decimalKeys]))
selectKeys = []
#print "inlinearKeys", inLinearKeys, outLinearKeys
if getFrom == "graphEditor":
selectKeys = list(
set([
round(loopKey) for loopKey in keysSel[thisStep]
if round(loopKey) in createKeys
]))
for loopKey in createKeys:
cmds.setKeyframe(loopCurve, time=(loopKey, loopKey), insert=True)
for loopKey in selectKeys:
cmds.selectKey(loopCurve, addTo=True, time=(loopKey, loopKey))
for loopKey in decimalKeys:
cmds.cutKey(loopCurve, time=(loopKey, loopKey))
#for loopKey in outLinearKeys: cmds.keyTangent(loopCurve, edit=True, time=(loopKey, loopKey), outTangentType="linear")
#for loopKey in inLinearKeys: cmds.keyTangent(loopCurve, edit=True, time=(loopKey, loopKey), inTangentType="linear")
estimatedTime = utilMod.chronoEnd(startChrono, firstStep, thisStep,
totalSteps)
utilMod.setProgressBar(endProgress=True)
def applyTangent(self,
animCurves,
tangentType,
getFrom,
time,
index,
tangentInOut="inOut"):
if self.isDefaultTangent(tangentType): #default maya tangents
if tangentType == "step":
cmds.keyTangent(animCurves,
edit=True,
time=time,
outTangentType=tangentType)
else:
if tangentInOut == "inOut" or tangentInOut == "in":
#print "applied in", time, tangentType
cmds.keyTangent(animCurves,
edit=True,
time=time,
inTangentType=tangentType)
if tangentInOut == "inOut" or tangentInOut == "out":
#print "applied out", time, tangentType
cmds.keyTangent(animCurves,
edit=True,
time=time,
outTangentType=tangentType)
else: #custom tangents
keyTimes = animMod.getTarget("keyTimes", animCurves)
keyIndexTimes = animMod.getTarget("keyIndexTimes", animCurves)
keysIndexSel = index
keyValues = animMod.getTarget("keyValues", animCurves)
cycleArray = []
tangentArray = []
for n, aCurve in enumerate(animCurves):
cycleArray.append([])
tangentArray.append([])
if keysIndexSel != None and keyTimes[
n] != None and keysIndexSel[n] != None and len(
keyTimes[n]) >= 2:
if keyValues[n][0] == keyValues[n][-1] and keysIndexSel[
n] == keyIndexTimes[n]: #it's a cycle
cycleArray[n] = True
else:
cycleArray[n] = False
#define tangent array
for i in keysIndexSel[n]:
tangentArray[n].append(
cmds.keyTangent(aCurve,
query=True,
index=(i, i),
inTangentType=True,
outTangentType=True,
inAngle=True,
outAngle=True))
passes = [self.averageTangent, self.flowTangent]
#passes = [averageTangent]
#self.fixTangentOvershoot, self.fixTangentOpposite
self.applyPass(passes, animCurves, keyTimes, keyValues,
keysIndexSel, tangentType)
# put back saved in out sides
for n, aCurve in enumerate(animCurves):
if keysIndexSel != None and keyTimes[
n] != None and keysIndexSel[n] != None and len(
keyTimes[n]) >= 2:
for nn, i in enumerate(keysIndexSel[n]):
tangent = tangentArray[n][nn]
if tangentInOut == "in":
cmds.keyTangent(aCurve,
edit=True,
index=(i, i),
lock=False)
cmds.keyTangent(aCurve,
edit=True,
index=(i, i),
outTangentType=tangent[3],
outAngle=tangent[1])
cmds.keyTangent(aCurve,
edit=True,
index=(i, i),
lock=True)
elif tangentInOut == "out":
cmds.keyTangent(aCurve,
edit=True,
index=(i, i),
lock=False)
cmds.keyTangent(aCurve,
edit=True,
index=(i, i),
inTangentType=tangent[2],
inAngle=tangent[0])
cmds.keyTangent(aCurve,
edit=True,
index=(i, i),
lock=True)
if tangentType == "flow":
# bounce ends
for n, aCurve in enumerate(animCurves):
first = None
last = None
if 0 in keysIndexSel[n]: first = True
if len(keyTimes[n]) - 1 in keysIndexSel[n]: last = True
if first and last:
self.bounceEnds([aCurve], "bounce", getFrom,
tangentInOut, [keyTimes[n]],
[keyIndexTimes[n]], "both")
elif first:
self.bounceEnds([aCurve], "bounce", getFrom,
tangentInOut, [keyTimes[n]],
[keyIndexTimes[n]], "first")
elif last:
self.bounceEnds([aCurve], "bounce", getFrom,
tangentInOut, [keyTimes[n]],
[keyIndexTimes[n]], "last")
#print "fl", first, last
# cycle?
for n, aCurve in enumerate(animCurves):
if cycleArray[n]:
angle = cmds.keyTangent(aCurve,
query=True,
index=(0, 0),
outAngle=True)[0]
cmds.keyTangent(aCurve,
time=(keyTimes[n][-1],
keyTimes[n][-1]),
inAngle=angle,
outAngle=angle)
def applyMirror(self, pasteAndCycle=False):
cmds.waitCursor(state=True)
range = animMod.getTimelineRange()
range[1] = int(range[1])
total = range[1] - range[0]
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
invertRules = self.getInvertRules()
if animCurves:
status = "aTools - Applying mirror..."
utilMod.startProgressBar(status)
totalSteps = len(animCurves)
firstStep = 0
thisStep = 0
estimatedTime = None
startChrono = None
mirrorCurves = animMod.getMirrorObjs(animCurves)
keyValues = animMod.getTarget("keyValues", animCurves, getFrom)
keyTimes = animMod.getTarget("keyTimes", animCurves, getFrom)
currValues = animMod.getTarget("currValues", animCurves, getFrom)
keysIndexSel = animMod.getTarget("keysIndexSel", animCurves,
getFrom)
keyTangentsAngle = animMod.getTarget("keyTangentsAngle",
animCurves, getFrom)
keyTangentsType = animMod.getTarget("keyTangentsType", animCurves,
getFrom)
currTime = cmds.currentTime(query=True)
if keysIndexSel:
#create dummy key
#objects = animMod.getObjsSel()
#mirrorObjs = animMod.getMirrorObjs(objects)
#animMod.createDummyKey(mirrorObjs)
for thisStep, aCurve in enumerate(animCurves):
startChrono = utilMod.chronoStart(startChrono, firstStep,
thisStep, totalSteps,
estimatedTime, status)
mCurve = mirrorCurves[thisStep]
isCenterCurve = (mCurve == None)
mirrorInvertValue = self.mirrorInvert(
aCurve, isCenterCurve, invertRules)
if mCurve and cmds.objExists(mCurve):
tCurve = mCurve
else:
tCurve = aCurve
if not cmds.objExists(tCurve): continue
animMod.createDummyKey([tCurve])
if len(keysIndexSel[thisStep]) > 0:
#delete keys
cmds.cutKey(
tCurve,
time=(
keyTimes[thisStep][keysIndexSel[thisStep][0]],
keyTimes[thisStep][keysIndexSel[thisStep][-1]]
),
clear=True)
for key in keysIndexSel[thisStep]:
keyValue = keyValues[thisStep][
key] * mirrorInvertValue
inTangAngleValue = keyTangentsAngle[thisStep][key][
0] * mirrorInvertValue
outTangAngleValue = keyTangentsAngle[thisStep][
key][1] * mirrorInvertValue
#apply keys
if pasteAndCycle:
t = keyTimes[thisStep][key] + (total / 2.)
if t == range[1]:
#repeat key at first frame
t1 = t - total
time = (t1, t1)
cmds.setKeyframe(tCurve,
time=time,
value=keyValue)
cmds.keyTangent(tCurve,
time=time,
inAngle=inTangAngleValue,
outAngle=outTangAngleValue)
cmds.keyTangent(
tCurve,
time=time,
inTangentType=keyTangentsType[thisStep]
[key][0],
outTangentType=keyTangentsType[
thisStep][key][1])
elif t > range[1]:
#fist half
t -= total
time = (t, t)
else:
time = (keyTimes[thisStep][key],
keyTimes[thisStep][key])
cmds.setKeyframe(tCurve, time=time, value=keyValue)
cmds.keyTangent(tCurve,
time=time,
inAngle=inTangAngleValue,
outAngle=outTangAngleValue)
cmds.keyTangent(
tCurve,
time=time,
inTangentType=keyTangentsType[thisStep][key]
[0],
outTangentType=keyTangentsType[thisStep][key]
[1])
else: #no keys#invert translate x
keyValue = currValues[thisStep] * mirrorInvertValue
#apply keys
cmds.setKeyframe(tCurve,
time=(currTime, currTime),
value=keyValue)
animMod.deleteDummyKey([tCurve])
estimatedTime = utilMod.chronoEnd(startChrono, firstStep,
thisStep, totalSteps)
#delete dummy key
#animMod.deleteDummyKey(mirrorObjs)
self.selectMirrorObjs(False)
utilMod.setProgressBar(endProgress=True)
animMod.refresh()
cmds.waitCursor(state=False)
def paste(self, type="onlyKeys"):
cmds.refresh(suspend=True)
selObjects = utilMod.getNameSpace(self.selection)[1]
self.locators = []
if self.targetObj != "world":
#CREATE
self.locatorGroup = animMod.group(name=self.locatorGroupName)
for n, loopObj in enumerate(self.sourceObjs):
nameSpace = utilMod.getNameSpace([loopObj])
loopSelName = "%s_%s" % (nameSpace[0][0], nameSpace[1][0])
locatorName = "fakeConstrain_%s" % loopSelName
locator = animMod.createNull(locatorName)
self.locators.append(locator)
with G.aToolsBar.createAToolsNode:
cmds.parent(locator, self.locatorGroup)
self.locators.append(self.locatorGroup)
currFrame = cmds.currentTime(query=True)
getCurves = animMod.getAnimCurves()
animCurves = getCurves[0]
getFrom = getCurves[1]
if animCurves:
keysSel = animMod.getTarget("keysSel", animCurves, getFrom)
keysSel = utilMod.mergeLists(keysSel)
if keysSel == []:
keysSel = [currFrame]
else:
keysSel = [currFrame]
frames = keysSel
if type == "allFrames":
frameRange = animMod.getTimelineRange(float=False)
frames = list(range(int(frameRange[0]), int(frameRange[1])))
if self.targetObj != "world":
G.aToolsBar.align.align([self.locatorGroup],
self.targetObj,
frames=frames)
for n, loopObj in enumerate(self.sourceObjs):
matrix = self.copyCache[n]
if self.targetObj != "world":
cmds.xform(self.locators[n], matrix=matrix)
G.aToolsBar.align.align([loopObj],
self.locators[n],
frames=frames,
showProgress=True)
else:
for loopFrame in frames:
cmds.currentTime(loopFrame)
cmds.xform(loopObj, ws=True, matrix=matrix)
cmds.currentTime(currFrame)
for loopFrame in frames:
for loopAttr in ["translate", "rotate"]:
breakdown = (loopFrame not in keysSel)
cmds.keyframe(loopObj,
edit=True,
attribute=loopAttr,
time=(loopFrame, loopFrame),
breakdown=breakdown)
if self.targetObj != "world":
self.clearLocators()
cmds.select(self.selection)
cmds.refresh(suspend=False)
