private static void ShiftAnimationClip(AnimationClip clip, float amount) { if (!(clip == null)) { EditorCurveBinding[] curveBindings = AnimationUtility.GetCurveBindings(clip); EditorCurveBinding[] objectReferenceCurveBindings = AnimationUtility.GetObjectReferenceCurveBindings(clip); EditorCurveBinding[] array = curveBindings; for (int i = 0; i < array.Length; i++) { EditorCurveBinding editorCurveBinding = array[i]; AnimationCurve editorCurve = AnimationUtility.GetEditorCurve(clip, editorCurveBinding); editorCurve.set_keys(AnimationTrackRecorder.ShiftKeys(editorCurve.get_keys(), amount)); AnimationUtility.SetEditorCurve(clip, editorCurveBinding, editorCurve); } EditorCurveBinding[] array2 = objectReferenceCurveBindings; for (int j = 0; j < array2.Length; j++) { EditorCurveBinding editorCurveBinding2 = array2[j]; ObjectReferenceKeyframe[] array3 = AnimationUtility.GetObjectReferenceCurve(clip, editorCurveBinding2); array3 = AnimationTrackRecorder.ShiftObjectKeys(array3, amount); AnimationUtility.SetObjectReferenceCurve(clip, editorCurveBinding2, array3); } EditorUtility.SetDirty(clip); } }
private static AnimationClip CloneAnimationClipIfRequired(AnimationClip clip, Object owner) { AnimationClip result; if (clip == null) { result = null; } else { string assetPath = AssetDatabase.GetAssetPath(clip); string assetPath2 = AssetDatabase.GetAssetPath(owner); bool flag = assetPath == assetPath2; if (flag) { AnimationClip animationClip = Object.Instantiate <AnimationClip>(clip); animationClip.set_name(AnimationTrackRecorder.GetUniqueRecordedClipName(owner, clip.get_name())); animationClip.set_hideFlags(clip.get_hideFlags()); if ((clip.get_hideFlags() & 52) != 52 && assetPath2.Length > 0) { TimelineHelpers.SaveAnimClipIntoObject(animationClip, owner); } EditorUtility.SetDirty(owner); clip = animationClip; } result = clip; } return(result); }
public static AnimationClip GetOrCreateClip(this AnimationTrack track) { if (track.infiniteClip == null && !track.inClipMode) { track.CreateInfiniteClip(AnimationTrackRecorder.GetUniqueRecordedClipName(track, AnimationTrackRecorder.kRecordClipDefaultName)); } return(track.infiniteClip); }
// Given a track, return the animation clip internal static AnimationClip FindRecordingAnimationClipAtTime(this TrackAsset trackAsset, double time) { if (trackAsset == null) { return(null); } AnimationTrack animTrack = trackAsset as AnimationTrack; if (animTrack != null && !animTrack.inClipMode) { return(animTrack.infiniteClip); } TimelineClip displayBackground; trackAsset.FindRecordingClipAtTime(time, out displayBackground); if (displayBackground != null) { if (displayBackground.recordable) { AnimationPlayableAsset asset = displayBackground.asset as AnimationPlayableAsset; if (asset != null) { return(asset.clip); } } else if (animTrack == null) { if (displayBackground.curves == null) { displayBackground.CreateCurves(AnimationTrackRecorder.GetUniqueRecordedClipName(displayBackground.parentTrack, TimelineClip.kDefaultCurvesName)); } return(displayBackground.curves); } } else if (trackAsset.HasAnyAnimatableParameters()) { if (trackAsset.curves == null) { trackAsset.CreateCurves(AnimationTrackRecorder.GetUniqueRecordedClipName(trackAsset.timelineAsset, TrackAsset.kDefaultCurvesName)); } return(trackAsset.curves); } return(null); }
static AnimationClip CloneAnimationClip(AnimationClip clip, Object owner) { if (clip == null) { return(null); } var newClip = Object.Instantiate(clip); newClip.name = AnimationTrackRecorder.GetUniqueRecordedClipName(owner, clip.name); SaveAnimClipIntoObject(newClip, owner); TimelineUndo.RegisterCreatedObjectUndo(newClip, "Create clip"); return(newClip); }
internal static TimelineClip Clone(TimelineClip clip, PlayableDirector director, PlayableAsset newOwner) { var editorClip = EditorClipFactory.GetEditorClip(clip); // Workaround for Clips not being unity object, assign it to a editor clip wrapper, clone it, and pull the clip back out var newClip = Object.Instantiate(editorClip).clip; // perform fix ups for what Instantiate cannot properly detect SelectionManager.Remove(newClip); newClip.parentTrack = null; newClip.curves = null; // instantiate might copy the reference, we need to clear it // curves are explicitly owned by the clip if (clip.curves != null) { newClip.CreateCurves(AnimationTrackRecorder.GetUniqueRecordedClipName(newOwner, clip.curves.name)); EditorUtility.CopySerialized(clip.curves, newClip.curves); TimelineCreateUtilities.SaveAssetIntoObject(newClip.curves, newOwner); } ScriptableObject playableAsset = newClip.asset as ScriptableObject; if (playableAsset != null && newClip.asset is IPlayableAsset) { var clone = CloneReferencedPlayableAsset(playableAsset, director); SaveCloneToAsset(clone, newOwner); newClip.asset = clone; // special case to make the name match the recordable clips, but only if they match on the original clip var originalRecordedAsset = clip.asset as AnimationPlayableAsset; if (clip.recordable && originalRecordedAsset != null && originalRecordedAsset.clip != null) { AnimationPlayableAsset clonedAnimationAsset = clone as AnimationPlayableAsset; if (clonedAnimationAsset != null && clonedAnimationAsset.clip != null) { clonedAnimationAsset.clip = CloneAnimationClip(originalRecordedAsset.clip, newOwner); if (clip.displayName == originalRecordedAsset.clip.name && newClip.recordable) { clonedAnimationAsset.name = clonedAnimationAsset.clip.name; newClip.displayName = clonedAnimationAsset.name; } } } } return(newClip); }
static void CreateCurvesOnDifferentOwner(TimelineClip clip, Object owner) { clip.curves = new AnimationClip { legacy = true, name = AnimationTrackRecorder.GetUniqueRecordedClipName(owner, TimelineClip.kDefaultCurvesName) }; var assetPath = AssetDatabase.GetAssetPath(owner); if (!string.IsNullOrEmpty(assetPath)) { TimelineHelpers.SaveAnimClipIntoObject(clip.curves, owner); EditorUtility.SetDirty(owner); AssetDatabase.ImportAsset(assetPath); AssetDatabase.Refresh(); } }
public void FinalizeRecording(TimelineWindow.TimelineState state) { for (int num = 0; num != this.m_ProcessedClips.Count; num++) { AnimationTrackRecorder.ProcessTemporaryKeys(this.m_ProcessedClips[num]); } this.m_RefreshState |= this.m_TracksToProcess.Any <TrackAsset>(); this.m_TracksToProcess.Clear(); if (this.m_ProcessedClips.Count > 0 || this.m_RefreshState) { state.GetWindow().RebuildGraphIfNecessary(false); } state.RebindAnimators(this.m_RebindList); if (this.m_ProcessedClips.Count > 0 || this.m_RefreshState) { state.EvaluateImmediate(); } }
internal static void CreateCurvesIfRequired(TimelineClip clip, Object owner = null) { if (owner == null) { owner = clip.parentTrack; } if (clip.curves == null) { if (owner == clip.parentTrack) { clip.CreateCurves(AnimationTrackRecorder.GetUniqueRecordedClipName(owner, TimelineClip.kDefaultCurvesName)); } else { CreateCurvesOnDifferentOwner(clip, owner); } } }
public static AnimationClip GetOrCreateClip(this TrackAsset track) { bool flag = false; AnimationTrack animationTrack = track as AnimationTrack; if (animationTrack != null) { flag = animationTrack.inClipMode; } if (track.animClip == null && !flag) { track.animClip = new AnimationClip(); track.animClip.set_name(AnimationTrackRecorder.GetUniqueRecordedClipName(track, AnimationTrackRecorder.kRecordClipDefaultName)); Undo.RegisterCreatedObjectUndo(track.animClip, "Create Track"); AnimationUtility.SetGenerateMotionCurves(track.animClip, true); TimelineHelpers.SaveAnimClipIntoObject(track.animClip, track); } return(track.animClip); }
internal static void CreateCurvesIfRequired(TimelineClip clip, TrackAsset parentTrack = null) { if (clip.curves == null) { if (parentTrack == null) { parentTrack = clip.parentTrack; } clip.AllocateAnimatedParameterCurves(); clip.curves.set_name(AnimationTrackRecorder.GetUniqueRecordedClipName(clip.parentTrack, AnimatedParameterExtensions.kDefaultClipName)); string assetPath = AssetDatabase.GetAssetPath(clip.parentTrack); if (!string.IsNullOrEmpty(assetPath)) { TimelineHelpers.SaveAnimClipIntoObject(clip.curves, clip.parentTrack); EditorUtility.SetDirty(clip.parentTrack); AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(clip.parentTrack)); AssetDatabase.Refresh(); } } }
private static void ProcessTemporaryKeys(AnimationClip clip) { if (!(clip == null)) { bool flag = false; EditorCurveBinding[] curveBindings = AnimationUtility.GetCurveBindings(clip); EditorCurveBinding[] array = curveBindings; for (int i = 0; i < array.Length; i++) { EditorCurveBinding editorCurveBinding = array[i]; if (!editorCurveBinding.propertyName.Contains("LocalRotation.w")) { EditorCurveBinding binding = RotationCurveInterpolation.RemapAnimationBindingForRotationCurves(editorCurveBinding, clip); flag |= AnimationTrackRecorder.ProcessCurveBinding(clip, binding); } } if (flag) { EditorUtility.SetDirty(clip); } } }
public static TimelineClip AddRecordableClip(TrackAsset parentTrack, TimelineWindow.TimelineState state) { TimelineAsset timeline = state.timeline; TimelineClip result; if (timeline == null) { Debug.LogError("Parent Track needs to be bound to an asset to add a recordable"); result = null; } else { AnimationClip animationClip = new AnimationClip(); animationClip.set_name(AnimationTrackRecorder.GetUniqueRecordedClipName(parentTrack, AnimationTrackRecorder.kRecordClipDefaultName)); animationClip.set_frameRate(state.frameRate); AnimationUtility.SetGenerateMotionCurves(animationClip, true); Undo.RegisterCreatedObjectUndo(animationClip, "Create Clip"); TimelineHelpers.SaveAnimClipIntoObject(animationClip, parentTrack); TimelineClip timelineClip = parentTrack.CreateClipFromAsset(animationClip); if (timelineClip != null) { timelineClip.recordable = true; timelineClip.displayName = animationClip.get_name(); timelineClip.timeScale = 1.0; timelineClip.start = 0.0; timelineClip.duration = 0.0; timelineClip.mixInCurve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f); timelineClip.mixOutCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f); timelineClip.preExtrapolationMode = TimelineClip.ClipExtrapolation.Hold; timelineClip.postExtrapolationMode = TimelineClip.ClipExtrapolation.Hold; TimelineCreateUtilities.SaveAssetIntoObject(timelineClip.asset, parentTrack); state.Refresh(); } result = timelineClip; } return(result); }
public static string GetUniqueRecordedClipName(this ICurvesOwner curvesOwner) { return(AnimationTrackRecorder.GetUniqueRecordedClipName(curvesOwner.assetOwner, curvesOwner.defaultCurvesName)); }
public static void SetStart(TimelineClip clip, double time) { var supportsClipIn = clip.SupportsClipIn(); var supportsPadding = TimelineUtility.IsRecordableAnimationClip(clip); // treat empty recordable clips as not supporting clip in (there are no keys to modify) if (supportsPadding && (clip.animationClip == null || clip.animationClip.empty)) { supportsClipIn = false; } if (supportsClipIn && !supportsPadding) { var minStart = clip.FromLocalTimeUnbound(0.0); if (time < minStart) { time = minStart; } } var maxStart = clip.end - TimelineClip.kMinDuration; if (time > maxStart) { time = maxStart; } var timeOffset = time - clip.start; var duration = clip.duration - timeOffset; if (supportsClipIn) { if (supportsPadding) { double clipInGlobal = clip.clipIn / clip.timeScale; double keyShift = -timeOffset; if (timeOffset < 0) // left drag, eliminate clipIn before shifting { double clipInDelta = Math.Max(-clipInGlobal, timeOffset); keyShift = -Math.Min(0, timeOffset - clipInDelta); clip.clipIn += clipInDelta * clip.timeScale; } else if (timeOffset > 0) // right drag, elimate padding in animation clip before adding clip in { var clipInfo = AnimationClipCurveCache.Instance.GetCurveInfo(clip.animationClip); double keyDelta = clip.FromLocalTimeUnbound(clipInfo.keyTimes.Min()) - clip.start; keyShift = -Math.Max(0, Math.Min(timeOffset, keyDelta)); clip.clipIn += Math.Max(timeOffset + keyShift, 0) * clip.timeScale; } if (keyShift != 0) { AnimationTrackRecorder.ShiftAnimationClip(clip.animationClip, (float)(keyShift * clip.timeScale)); } } else { clip.clipIn += timeOffset * clip.timeScale; } } clip.start = time; clip.duration = duration; clip.ConformEaseValues(); }
public AnimationClip PrepareTrack(TrackAsset track, TimelineWindow.TimelineState state, GameObject gameObject, out double startTime) { AnimationTrack animationTrack = (AnimationTrack)track; AnimationClip result; if (!animationTrack.inClipMode) { AnimationClip orCreateClip = animationTrack.GetOrCreateClip(); startTime = (double)orCreateClip.get_frameRate() * state.time; if (!this.m_TracksToProcess.Contains(animationTrack)) { this.m_TracksToProcess.Add(animationTrack); } this.m_RebindList.Add(gameObject); if (orCreateClip.get_empty()) { animationTrack.openClipTimeOffset = 0.0; animationTrack.openClipPreExtrapolation = TimelineClip.ClipExtrapolation.Hold; animationTrack.openClipPostExtrapolation = TimelineClip.ClipExtrapolation.Hold; } result = orCreateClip; } else { TimelineClip timelineClip = AnimationTrackRecorder.GetRecordingClipForTrack(track, state); if (timelineClip == null) { timelineClip = track.FindRecordingClipAtTime(state.time); } List <TimelineClip> list = (from x in track.clips where x.start <= state.time && x.end >= state.time select x).ToList <TimelineClip>(); if (timelineClip == null) { if (list.Count != 0) { if (list.Count > 0) { if (list.Any((TimelineClip x) => x.recordable)) { goto IL_12A; } } Debug.LogWarning("Cannot record on top of an imported animation clip"); startTime = -1.0; result = null; return(result); } IL_12A: timelineClip = AnimationTrackRecorder.AddRecordableClip(track, state); timelineClip.start = state.time; this.m_RebindList.Add(gameObject); } AnimationClip animationClip = timelineClip.animationClip; double num = state.time - timelineClip.start; if (num < 0.0) { Undo.RegisterCompleteObjectUndo(animationClip, "Record Key"); TimelineUndo.PushUndo(track, "Prepend Key"); AnimationTrackRecorder.ShiftAnimationClip(animationClip, (float)(-(float)num)); timelineClip.start = state.time; timelineClip.duration += -num; num = 0.0; this.m_RefreshState = true; } this.m_ClipTime = num; this.recordClip = timelineClip; startTime = (double)TimeUtility.ToFrames(this.recordClip.ToLocalTimeUnbound(state.time), (double)animationClip.get_frameRate()); this.m_needRebuildRects = animationClip.get_empty(); result = animationClip; } return(result); }