private void DoManipulators()
{
if (!(this.m_EditorClip == null) && this.m_EditorClip.clip != null)
{
AnimationPlayableAsset animationPlayableAsset = this.m_EditorClip.clip.asset as AnimationPlayableAsset;
AnimationTrack animationTrack = this.m_EditorClip.clip.parentTrack as AnimationTrack;
Transform transform = this.GetTransform();
if (transform != null && animationPlayableAsset != null && this.m_OffsetEditMode != TimelineAnimationUtilities.OffsetEditMode.None && animationTrack != null)
{
Vector3 vector = transform.get_position();
Quaternion quaternion = transform.get_rotation();
EditorGUI.BeginChangeCheck();
if (this.m_OffsetEditMode == TimelineAnimationUtilities.OffsetEditMode.Translation)
{
vector = Handles.PositionHandle(vector, (Tools.get_pivotRotation() != 1) ? quaternion : Quaternion.get_identity());
}
else if (this.m_OffsetEditMode == TimelineAnimationUtilities.OffsetEditMode.Rotation)
{
quaternion = Handles.RotationHandle(quaternion, vector);
}
if (EditorGUI.EndChangeCheck())
{
TimelineAnimationUtilities.RigidTransform rigidTransform = TimelineAnimationUtilities.UpdateClipOffsets(animationPlayableAsset, animationTrack, transform, vector, quaternion);
animationPlayableAsset.position = rigidTransform.position;
animationPlayableAsset.rotation = rigidTransform.rotation;
this.Reevaluate();
base.Repaint();
}
}
}
}
private void DoOffsetManipulator()
{
if (base.get_targets().Length <= 1)
{
if (!(base.timelineWindow == null) && base.timelineWindow.state != null && !(base.timelineWindow.state.currentDirector == null))
{
AnimationTrack animationTrack = base.get_target() as AnimationTrack;
if (animationTrack != null && animationTrack.applyOffsets && this.m_OffsetEditMode != TimelineAnimationUtilities.OffsetEditMode.None)
{
GameObject sceneGameObject = TimelineUtility.GetSceneGameObject(base.timelineWindow.state.currentDirector, animationTrack);
Transform transform = (!(sceneGameObject != null)) ? null : sceneGameObject.get_transform();
TimelineAnimationUtilities.RigidTransform trackOffsets = TimelineAnimationUtilities.GetTrackOffsets(animationTrack, transform);
EditorGUI.BeginChangeCheck();
TimelineAnimationUtilities.OffsetEditMode offsetEditMode = this.m_OffsetEditMode;
if (offsetEditMode != TimelineAnimationUtilities.OffsetEditMode.Translation)
{
if (offsetEditMode == TimelineAnimationUtilities.OffsetEditMode.Rotation)
{
trackOffsets.rotation = Handles.RotationHandle(trackOffsets.rotation, trackOffsets.position);
}
}
else
{
trackOffsets.position = Handles.PositionHandle(trackOffsets.position, (Tools.get_pivotRotation() != 1) ? trackOffsets.rotation : Quaternion.get_identity());
}
if (EditorGUI.EndChangeCheck())
{
TimelineAnimationUtilities.UpdateTrackOffset(animationTrack, transform, trackOffsets);
this.Evaluate();
base.Repaint();
}
}
}
}
}
public override bool Execute(IEnumerable <TimelineClip> clips)
{
var clip = clips.FirstOrDefault();
if (clip != null && (clip.curves != null || clip.animationClip != null))
{
var clipToEdit = clip.animationClip != null ? clip.animationClip : clip.curves;
if (clipToEdit == null)
{
return(false);
}
GameObject gameObject = null;
if (TimelineEditor.inspectedDirector != null)
{
gameObject = TimelineUtility.GetSceneGameObject(TimelineEditor.inspectedDirector, clip.parentTrack);
}
var timeController = TimelineAnimationUtilities.CreateTimeController(clip);
TimelineAnimationUtilities.EditAnimationClipWithTimeController(
clipToEdit, timeController, clip.animationClip != null ? gameObject : null);
return(true);
}
return(false);
}
public static bool Do(WindowState state, TrackAsset track)
{
AnimationClip clipToEdit = null;
AnimationTrack animationTrack = track as AnimationTrack;
if (animationTrack != null)
{
if (!animationTrack.CanConvertToClipMode())
{
return(false);
}
clipToEdit = animationTrack.infiniteClip;
}
else if (track.hasCurves)
{
clipToEdit = track.curves;
}
if (clipToEdit == null)
{
return(false);
}
var gameObject = state.GetSceneReference(track);
var timeController = TimelineAnimationUtilities.CreateTimeController(state, CreateTimeControlClipData(track));
TimelineAnimationUtilities.EditAnimationClipWithTimeController(clipToEdit, timeController, gameObject);
return(true);
}
public override bool Execute(TimelineWindow.TimelineState state, TimelineClip[] clips)
{
TimelineClip timelineClip = clips[0];
bool result;
if (timelineClip.curves != null || timelineClip.animationClip != null)
{
AnimationClip animationClip = (!(timelineClip.animationClip != null)) ? timelineClip.curves : timelineClip.animationClip;
if (animationClip == null)
{
result = false;
}
else
{
Component bindingForTrack = state.GetBindingForTrack(timelineClip.parentTrack);
TimelineWindowTimeControl timeController = TimelineAnimationUtilities.CreateTimeController(state, timelineClip);
TimelineAnimationUtilities.EditAnimationClipWithTimeController(animationClip, timeController, (!(timelineClip.animationClip != null)) ? null : bindingForTrack);
result = true;
}
}
else
{
result = false;
}
return(result);
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
base.get_serializedObject().Update();
bool flag = this.m_lastPosition != this.m_TrackPositionProperty.get_vector3Value() || this.m_lastRotation != this.m_TrackRotationProperty.get_quaternionValue();
this.m_lastPosition = this.m_TrackPositionProperty.get_vector3Value();
this.m_lastRotation = this.m_TrackRotationProperty.get_quaternionValue();
EditorGUI.BeginChangeCheck();
this.DrawAvatarProperties();
if (EditorGUI.EndChangeCheck())
{
this.RebuildGraph();
}
if (base.get_targets().Length == 1)
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(this.m_ApplyOffsetsProperty, AnimationTrackInspector.Styles.TrackOffsetTitle, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
this.RebuildGraph();
}
Animator animator = this.GetAnimator();
bool flag2 = animator == null || !TimelineAnimationUtilities.ValidateOffsetAvailabitity(base.timelineWindow.state.currentDirector, animator) || !this.m_ApplyOffsetsProperty.get_boolValue();
using (new EditorGUI.DisabledScope(flag2))
{
EditorGUI.set_indentLevel(EditorGUI.get_indentLevel() + 1);
float num = 0f;
float num2 = 0f;
GUI.get_skin().get_button().CalcMinMaxWidth(AnimationTrackInspector.Styles.PositionIcon, ref num, ref num2);
AnimationTrackInspector.ShowMotionOffsetEditModeToolbar(ref this.m_OffsetEditMode);
SceneView.RepaintAll();
EditorGUI.BeginChangeCheck();
EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
EditorGUILayout.PropertyField(this.m_TrackPositionProperty, new GUILayoutOption[0]);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
AnimationPlayableAssetInspector.ShowRotationField(this.m_TrackRotationProperty);
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUI.set_indentLevel(EditorGUI.get_indentLevel() - 1);
flag |= EditorGUI.EndChangeCheck();
if (flag)
{
AnimationTrack animationTrack = (AnimationTrack)base.get_target();
animationTrack.UpdateClipOffsets();
this.Evaluate();
}
}
}
else
{
GUILayout.Label(AnimationTrackInspector.Styles.TrackOffsetCannotBeEditedWarning, EditorStyles.get_helpBox(), new GUILayoutOption[0]);
}
AnimationTrackInspector.MatchTargetsField(this.m_MatchFieldsProperty, null, null, false);
base.get_serializedObject().ApplyModifiedProperties();
}
void OnDestroy()
{
if (state != null)
{
state.OnDestroy();
}
m_HasBeenInitialized = false;
RemoveEditorCallbacks();
TimelineAnimationUtilities.UnlinkAnimationWindow();
}
internal static void DeleteItems(IEnumerable <ITimelineItem> items)
{
var tracks = items.GroupBy(c => c.parentTrack);
foreach (var track in tracks)
{
TimelineUndo.PushUndo(track.Key, "Delete Items");
}
TimelineAnimationUtilities.UnlinkAnimationWindowFromClips(items.OfType <ClipItem>().Select(i => i.clip));
EditMode.PrepareItemsDelete(ItemsUtils.ToItemsPerTrack(items));
EditModeUtils.Delete(items);
SelectionManager.RemoveAllClips();
}
void OnAfterSequenceChange()
{
Repaint();
m_SequencePath = state.GetCurrentSequencePath();
m_LastFrameHadSequence = state.editSequence.asset != null;
TimelineWindowViewPrefs.SaveAll();
// this prevent clearing the animation window when going in/out of playmode, but
// clears it when we switch master timelines
if (m_PreviousMasterSequence != null && m_PreviousMasterSequence != state.masterSequence.asset)
{
TimelineAnimationUtilities.UnlinkAnimationWindow();
}
}
public override bool Execute(WindowState state, TrackAsset[] tracks)
{
// disable preview mode so deleted tracks revert to default state
// Case 956129: Disable preview mode _before_ deleting the tracks, since clip data is still needed
state.previewMode = false;
TimelineAnimationUtilities.UnlinkAnimationWindowFromTracks(tracks);
foreach (var track in tracks)
{
Do(state.editSequence.asset, track);
}
state.Refresh();
return(true);
}
public override bool Execute(IEnumerable <TrackAsset> tracks)
{
// disable preview mode so deleted tracks revert to default state
// Case 956129: Disable preview mode _before_ deleting the tracks, since clip data is still needed
TimelineEditor.state.previewMode = false;
TimelineAnimationUtilities.UnlinkAnimationWindowFromTracks(tracks);
foreach (var track in tracks)
{
Do(TimelineEditor.inspectedAsset, track);
}
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
return(true);
}
internal static void MatchClipsToNext(ITimelineState state, TimelineClip[] clips)
{
if (AnimationOffsetMenu.EnforcePreviewMode(state))
{
clips = (from x in clips
orderby x.start descending
select x).ToArray <TimelineClip>();
TimelineClip[] array = clips;
for (int i = 0; i < array.Length; i++)
{
TimelineClip timelineClip = array[i];
TimelineUndo.PushUndo(timelineClip.asset, "Match Clip");
GameObject sceneGameObject = TimelineUtility.GetSceneGameObject(state.currentDirector, timelineClip.parentTrack);
TimelineAnimationUtilities.MatchNext(timelineClip, sceneGameObject.get_transform(), state.currentDirector);
}
}
}
void DoOffsetManipulator()
{
if (targets.Length > 1) //do not edit the track offset on a multiple selection
{
return;
}
if (timelineWindow == null || timelineWindow.state == null || timelineWindow.state.editSequence.director == null)
{
return;
}
AnimationTrack animationTrack = target as AnimationTrack;
if (animationTrack != null && (animationTrack.trackOffset == TrackOffset.ApplyTransformOffsets) && m_OffsetEditMode != TimelineAnimationUtilities.OffsetEditMode.None)
{
var boundObject = TimelineUtility.GetSceneGameObject(timelineWindow.state.editSequence.director, animationTrack);
var boundObjectTransform = boundObject != null ? boundObject.transform : null;
var offsets = TimelineAnimationUtilities.GetTrackOffsets(animationTrack, boundObjectTransform);
EditorGUI.BeginChangeCheck();
switch (m_OffsetEditMode)
{
case TimelineAnimationUtilities.OffsetEditMode.Translation:
offsets.position = Handles.PositionHandle(offsets.position, (Tools.pivotRotation == PivotRotation.Global)
? Quaternion.identity
: offsets.rotation);
break;
case TimelineAnimationUtilities.OffsetEditMode.Rotation:
offsets.rotation = Handles.RotationHandle(offsets.rotation, offsets.position);
break;
}
if (EditorGUI.EndChangeCheck())
{
UndoExtensions.RegisterTrack(animationTrack, L10n.Tr("Inspector"));
TimelineAnimationUtilities.UpdateTrackOffset(animationTrack, boundObjectTransform, offsets);
Evaluate();
Repaint();
}
}
}
public static void MatchPrevious(TimelineClip currentClip, Transform matchPoint, PlayableDirector director)
{
MatchTargetFields matchFields = TimelineAnimationUtilities.GetMatchFields(currentClip);
if (matchFields != MatchTargetFieldConstants.None && !(matchPoint == null))
{
double time = director.get_time();
TimelineClip previousClip = TimelineAnimationUtilities.GetPreviousClip(currentClip);
if (previousClip != null && currentClip != previousClip)
{
AnimationTrack animationTrack = currentClip.parentTrack as AnimationTrack;
double blendInDuration = currentClip.blendInDuration;
currentClip.blendInDuration = 0.0;
double blendOutDuration = previousClip.blendOutDuration;
previousClip.blendOutDuration = 0.0;
director.Stop();
animationTrack.RemoveClip(currentClip);
director.Play();
double num = (currentClip.start <= previousClip.end) ? currentClip.start : previousClip.end;
director.set_time(num - 1E-05);
director.Evaluate();
Vector3 position = matchPoint.get_position();
Quaternion rotation = matchPoint.get_rotation();
director.Stop();
animationTrack.AddClip(currentClip);
animationTrack.RemoveClip(previousClip);
director.Play();
director.set_time(currentClip.start + 1E-05);
director.Evaluate();
AnimationPlayableAsset asset = currentClip.asset as AnimationPlayableAsset;
TimelineAnimationUtilities.RigidTransform result = TimelineAnimationUtilities.UpdateClipOffsets(asset, animationTrack, matchPoint, position, rotation);
TimelineAnimationUtilities.WriteMatchFields(asset, result, matchFields);
currentClip.blendInDuration = blendInDuration;
previousClip.blendOutDuration = blendOutDuration;
director.Stop();
animationTrack.AddClip(previousClip);
director.Play();
director.set_time(time);
director.Evaluate();
}
}
}
internal static void MatchClipsToNext(TimelineClip[] clips)
{
if (!EnforcePreviewMode())
{
return;
}
clips = clips.OrderByDescending(x => x.start).ToArray();
foreach (var clip in clips)
{
var sceneObject = TimelineUtility.GetSceneGameObject(TimelineEditor.inspectedDirector, clip.GetParentTrack());
if (sceneObject != null)
{
TimelineAnimationUtilities.MatchNext(clip, sceneObject.transform, TimelineEditor.inspectedDirector);
}
}
InspectorWindow.RepaintAllInspectors();
TimelineEditor.Refresh(RefreshReason.ContentsModified);
}
public override bool Execute(WindowState state, TimelineClip[] clips)
{
var clip = clips[0];
if (clip.curves != null || clip.animationClip != null)
{
var clipToEdit = clip.animationClip != null ? clip.animationClip : clip.curves;
if (clipToEdit == null)
{
return(false);
}
var gameObject = state.GetSceneReference(clip.parentTrack);
var timeController = TimelineAnimationUtilities.CreateTimeController(state, clip);
TimelineAnimationUtilities.EditAnimationClipWithTimeController(
clipToEdit, timeController, clip.animationClip != null ? gameObject : null);
return(true);
}
return(false);
}
void OnAfterSequenceChange()
{
Repaint();
m_SequencePath = state.GetCurrentSequencePath();
m_LastFrameHadSequence = state.editSequence.asset != null;
TimelineWindowViewPrefs.SaveAll();
// this prevent clearing the animation window when going in/out of playmode, but
// clears it when we switch master timelines
// the cast to a object will handle the case where the sequence has been deleted.
object previousMasterSequence = m_PreviousMasterSequence;
bool isDeleted = previousMasterSequence != null && m_PreviousMasterSequence == null;
bool hasChanged = m_PreviousMasterSequence != null && m_PreviousMasterSequence != state.masterSequence.asset;
if (isDeleted || hasChanged)
{
TimelineAnimationUtilities.UnlinkAnimationWindow();
}
}
internal static void MatchClipsToNext(WindowState state, TimelineClip[] clips)
{
if (!EnforcePreviewMode(state))
{
return;
}
clips = clips.OrderByDescending(x => x.start).ToArray();
foreach (var clip in clips)
{
var sceneObject = TimelineUtility.GetSceneGameObject(state.editSequence.director, clip.parentTrack);
if (sceneObject != null)
{
TimelineUndo.PushUndo(clip.asset, "Match Clip");
TimelineAnimationUtilities.MatchNext(clip, sceneObject.transform, state.editSequence.director);
}
}
InspectorWindow.RepaintAllInspectors();
TimelineEditor.Refresh(RefreshReason.ContentsModified);
}
public static bool Do(TimelineWindow.TimelineState state, TrackAsset track)
{
AnimationTrack animationTrack = track as AnimationTrack;
bool result;
if (animationTrack == null)
{
result = false;
}
else if (!animationTrack.CanConvertToClipMode())
{
result = false;
}
else
{
Component bindingForTrack = state.GetBindingForTrack(animationTrack);
TimelineWindowTimeControl timeController = TimelineAnimationUtilities.CreateTimeController(state, EditTrackInAnimationWindow.CreateTimeControlClipData(animationTrack));
TimelineAnimationUtilities.EditAnimationClipWithTimeController(animationTrack.animClip, timeController, (!(bindingForTrack != null)) ? null : bindingForTrack.get_gameObject());
result = true;
}
return(result);
}
public static bool Do(TrackAsset track)
{
AnimationClip clipToEdit = null;
AnimationTrack animationTrack = track as AnimationTrack;
if (animationTrack != null)
{
if (!animationTrack.CanConvertToClipMode())
{
return(false);
}
clipToEdit = animationTrack.infiniteClip;
}
else if (track.hasCurves)
{
clipToEdit = track.curves;
}
if (clipToEdit == null)
{
return(false);
}
GameObject gameObject = null;
if (TimelineEditor.inspectedDirector != null)
{
gameObject = TimelineUtility.GetSceneGameObject(TimelineEditor.inspectedDirector, track);
}
var timeController = TimelineAnimationUtilities.CreateTimeController(CreateTimeControlClipData(track));
TimelineAnimationUtilities.EditAnimationClipWithTimeController(clipToEdit, timeController, gameObject);
return(true);
}
void DoManipulators()
{
if (m_EditorClip == null || m_EditorClip.clip == null)
{
return;
}
AnimationPlayableAsset animationPlayable = m_EditorClip.clip.asset as AnimationPlayableAsset;
AnimationTrack track = m_EditorClip.clip.parentTrack as AnimationTrack;
Transform transform = GetTransform();
if (transform != null && animationPlayable != null && m_OffsetEditMode != TimelineAnimationUtilities.OffsetEditMode.None && track != null)
{
UndoExtensions.RegisterPlayableAsset(animationPlayable, "Inspector");
Vector3 position = transform.position;
Quaternion rotation = transform.rotation;
EditorGUI.BeginChangeCheck();
if (m_OffsetEditMode == TimelineAnimationUtilities.OffsetEditMode.Translation)
{
position = Handles.PositionHandle(position, Tools.pivotRotation == PivotRotation.Global ? Quaternion.identity : rotation);
}
else if (m_OffsetEditMode == TimelineAnimationUtilities.OffsetEditMode.Rotation)
{
rotation = Handles.RotationHandle(rotation, position);
}
if (EditorGUI.EndChangeCheck())
{
var res = TimelineAnimationUtilities.UpdateClipOffsets(animationPlayable, track, transform, position, rotation);
animationPlayable.position = res.position;
animationPlayable.eulerAngles = AnimationUtility.GetClosestEuler(res.rotation, animationPlayable.eulerAngles, RotationOrder.OrderZXY);
Reevaluate();
Repaint();
}
}
}
void ApplyConstraints(EditorCurveBinding binding, AnimationCurve curve)
{
if (curve.length == 0)
{
return;
}
var curveUpdated = false;
var property = m_PropertiesMap[binding];
if (property.propertyType == SerializedPropertyType.Boolean)
{
TimelineAnimationUtilities.ConstrainCurveToBooleanValues(curve);
curveUpdated = true;
}
else
{
var range = AnimatedParameterUtility.GetAttributeForProperty <RangeAttribute>(property);
if (range != null)
{
TimelineAnimationUtilities.ConstrainCurveToRange(curve, range.min, range.max);
curveUpdated = true;
}
}
if (!curveUpdated)
{
return;
}
using (new RebuildGuard(this))
{
AnimationUtility.SetEditorCurve(m_ProxyCurves, binding, curve);
}
}
public override bool Execute(IEnumerable <TimelineClip> clips)
{
TimelineClip clip;
AnimationClip clipToEdit;
if (!GetEditableClip(clips, out clip, out clipToEdit))
{
return(false);
}
GameObject gameObject = null;
if (TimelineEditor.inspectedDirector != null)
{
gameObject = TimelineUtility.GetSceneGameObject(TimelineEditor.inspectedDirector, clip.parentTrack);
}
var timeController = TimelineAnimationUtilities.CreateTimeController(clip);
TimelineAnimationUtilities.EditAnimationClipWithTimeController(
clipToEdit, timeController, clip.animationClip != null ? gameObject : null);
return(true);
}
