diff --git a/.gitattributes b/.gitattributes index 1c926df21f5de5b7abd0d1e0f8f4aa31bc1600aa..7a64e2f5a7e320e6546a9ae3f81620e8a3f623e1 100644 --- a/.gitattributes +++ b/.gitattributes @@ -604,3 +604,23 @@ benchmark/iGeo/2025-WRT-Marking-Scheme.pdf filter=lfs diff=lfs merge=lfs -text benchmark/iGeo/2025-WRT-Resource-Booklet.pdf filter=lfs diff=lfs merge=lfs -text benchmark/iGeo/FWE-1A-QUESTION_2018iGeo.pdf filter=lfs diff=lfs merge=lfs -text benchmark/iGeo/FWE-1A_Map-A2_Large_2018iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE-1B_QUESTION_2018iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE-1_Student-booklet_2024iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE-2_Map-C2_2018iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE-2_QUESTION_2018iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE-2_Student-booklet_2024iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE_Briefing-v1_2019iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE_Information-Booklet_2024iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE_Instructions_2019iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE_Mark-Scheme_2024iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE_Task1_QP_2019iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE_Task2_QP_2019iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE_Task_maps_2019iGeo_20190722.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/FWE_Test_QP_2019iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/MMT-Sample-Questions.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/WRT-2022-Question-and-Resource-Booklet.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/WRT-2024-Question-and-Answer-Booklet.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/WRT_Marking-Scheme_2018iGeo_final_version.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/WRT_Marking-Scheme_2024iGeo.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/WRT_Marking_Scheme_2019-iGeo_Hong-Kong.pdf filter=lfs diff=lfs merge=lfs -text +benchmark/iGeo/WRT_QA-Booklet_iGeo-2019.pdf filter=lfs diff=lfs merge=lfs -text diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ActionContext.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ActionContext.cs new file mode 100644 index 0000000000000000000000000000000000000000..c07e661cb8f494630cd396d0ef71a9015ae96d36 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ActionContext.cs @@ -0,0 +1,63 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Actions +{ + /// + /// Action context to be used by actions. + /// + /// + /// + public struct ActionContext + { + IEnumerable m_Tracks; + IEnumerable m_Clips; + IEnumerable m_Markers; + + /// + /// The Timeline asset that is currently opened in the Timeline window. + /// + public TimelineAsset timeline; + + /// + /// The PlayableDirector that is used to play the current Timeline asset. + /// + public PlayableDirector director; + + /// + /// Time based on the position of the cursor on the timeline (in seconds). + /// null if the time is not available (in case of a shortcut for example). + /// + public double? invocationTime; + + /// + /// Tracks that will be used by the actions. + /// + public IEnumerable tracks + { + get => m_Tracks ?? Enumerable.Empty(); + set => m_Tracks = value; + } + + /// + /// Clips that will be used by the actions. + /// + public IEnumerable clips + { + get => m_Clips ?? Enumerable.Empty(); + set => m_Clips = value; + } + + /// + /// Markers that will be used by the actions. + /// + public IEnumerable markers + { + get => m_Markers ?? Enumerable.Empty(); + set => m_Markers = value; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ActionContext.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ActionContext.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e284e1fd625221dd9fdb5707f4f752c60191402c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ActionContext.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5e79d50dea5c9c74d9297cce6cd6d053 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ActionManager.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ActionManager.cs new file mode 100644 index 0000000000000000000000000000000000000000..d3f0bd6eda8d061a710c8a17d4a3e7ca469b44f2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ActionManager.cs @@ -0,0 +1,306 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Actions +{ + static class ActionManager + { + static bool s_ShowActionTriggeredByShortcut = false; + + public static readonly IReadOnlyList TimelineActions = InstantiateClassesOfType(); + public static readonly IReadOnlyList ClipActions = InstantiateClassesOfType(); + public static readonly IReadOnlyList TrackActions = InstantiateClassesOfType(); + public static readonly IReadOnlyList MarkerActions = InstantiateClassesOfType(); + + public static readonly IReadOnlyList TimelineActionsWithShortcuts = ActionsWithShortCuts(TimelineActions); + public static readonly IReadOnlyList ClipActionsWithShortcuts = ActionsWithShortCuts(ClipActions); + public static readonly IReadOnlyList TrackActionsWithShortcuts = ActionsWithShortCuts(TrackActions); + public static readonly IReadOnlyList MarkerActionsWithShortcuts = ActionsWithShortCuts(MarkerActions); + + public static readonly HashSet ActionsWithAutoUndo = TypesWithAttribute(); + + public static TU GetCachedAction(this IReadOnlyList list) where T : TU + { + return list.FirstOrDefault(x => x.GetType() == typeof(T)); + } + + public static void GetMenuEntries(IReadOnlyList actions, Vector2? mousePos, List menuItems, MenuFilter filter = MenuFilter.Default) + { + var globalContext = TimelineEditor.CurrentContext(mousePos); + foreach (var action in actions) + { + try + { + BuildMenu(action, globalContext, menuItems, filter); + } + catch (Exception e) + { + Debug.LogException(e); + } + } + } + + public static void GetMenuEntries(IReadOnlyList actions, List menuItems, MenuFilter filter = MenuFilter.Track) + { + var tracks = SelectionManager.SelectedTracks(); + if (!tracks.Any()) + return; + + foreach (var action in actions) + { + try + { + BuildMenu(action, tracks, menuItems, filter); + } + catch (Exception e) + { + Debug.LogException(e); + } + } + } + + public static void GetMenuEntries(IReadOnlyList actions, List menuItems, MenuFilter filter = MenuFilter.Item) + { + var clips = SelectionManager.SelectedClips(); + bool any = clips.Any(); + if (!clips.Any()) + return; + + foreach (var action in actions) + { + try + { + if (action is EditSubTimeline editSubTimelineAction) + editSubTimelineAction.AddMenuItem(menuItems); + else if (any) + BuildMenu(action, clips, menuItems, filter); + } + catch (Exception e) + { + Debug.LogException(e); + } + } + } + + public static void GetMenuEntries(IReadOnlyList actions, List menuItems, MenuFilter filter = MenuFilter.Item) + { + var markers = SelectionManager.SelectedMarkers(); + if (!markers.Any()) + return; + + foreach (var action in actions) + { + try + { + BuildMenu(action, markers, menuItems, filter); + } + catch (Exception e) + { + Debug.LogException(e); + } + } + } + + static void BuildMenu(TimelineAction action, ActionContext context, List menuItems, MenuFilter filter) + { + BuildMenu(action, action.Validate(context), () => ExecuteTimelineAction(action, context), menuItems, filter); + } + + static void BuildMenu(TrackAction action, IEnumerable tracks, List menuItems, MenuFilter filter) + { + BuildMenu(action, action.Validate(tracks), () => ExecuteTrackAction(action, tracks), menuItems, filter); + } + + static void BuildMenu(ClipAction action, IEnumerable clips, List menuItems, MenuFilter filter) + { + BuildMenu(action, action.Validate(clips), () => ExecuteClipAction(action, clips), menuItems, filter); + } + + static void BuildMenu(MarkerAction action, IEnumerable markers, List menuItems, MenuFilter filter) + { + BuildMenu(action, action.Validate(markers), () => ExecuteMarkerAction(action, markers), menuItems, filter); + } + + static void BuildMenu(IAction action, ActionValidity validity, GenericMenu.MenuFunction executeFunction, List menuItems, MenuFilter filter, bool isChecked = false) + { + var menuAttribute = action.GetType().GetCustomAttribute(false); + if (menuAttribute == null || filter.ShouldFilterOut(menuAttribute)) + return; + + if (validity == ActionValidity.NotApplicable) + return; + + var menuActionItem = new MenuActionItem + { + state = validity, + entryName = action.GetMenuEntryName(), + priority = menuAttribute.priority, + category = menuAttribute.subMenuPath, + isActiveInMode = action.IsActionActiveInMode(TimelineWindow.instance.currentMode.mode), + shortCut = action.GetShortcut(), + callback = executeFunction, + isChecked = action.IsChecked() + }; + menuItems.Add(menuActionItem); + } + + internal static void BuildMenu(GenericMenu menu, List items) + { + // sorted the outer menu by priority, then sort the innermenu by priority + var sortedItems = + items.GroupBy(x => string.IsNullOrEmpty(x.category) ? x.entryName : x.category).OrderBy(x => x.Min(y => y.priority)).SelectMany(x => x.OrderBy(z => z.priority)); + + int lastPriority = Int32.MinValue; + string lastCategory = string.Empty; + + foreach (var s in sortedItems) + { + if (s.state == ActionValidity.NotApplicable) + continue; + + var priority = s.priority; + if (lastPriority != int.MinValue && priority / MenuPriority.separatorAt > lastPriority / MenuPriority.separatorAt) + { + string path = string.Empty; + if (lastCategory == s.category) + path = s.category; + menu.AddSeparator(path); + } + + lastPriority = priority; + lastCategory = s.category; + + string entry = s.category + s.entryName; + if (!string.IsNullOrEmpty(s.shortCut)) + entry += " " + s.shortCut; + + if (s.state == ActionValidity.Valid && s.isActiveInMode) + menu.AddItem(new GUIContent(entry), s.isChecked, s.callback); + else + menu.AddDisabledItem(new GUIContent(entry), s.isChecked); + } + } + + public static bool HandleShortcut(Event evt) + { + if (EditorGUI.IsEditingTextField()) + return false; + + return HandleShortcut(evt, TimelineActionsWithShortcuts, (x) => ExecuteTimelineAction(x, TimelineEditor.CurrentContext())) || + HandleShortcut(evt, ClipActionsWithShortcuts, (x => ExecuteClipAction(x, SelectionManager.SelectedClips()))) || + HandleShortcut(evt, TrackActionsWithShortcuts, (x => ExecuteTrackAction(x, SelectionManager.SelectedTracks()))) || + HandleShortcut(evt, MarkerActionsWithShortcuts, (x => ExecuteMarkerAction(x, SelectionManager.SelectedMarkers()))); + } + + public static bool HandleShortcut(Event evt, IReadOnlyList actions, Func invoke) where T : class, IAction + { + for (int i = 0; i < actions.Count; i++) + { + var action = actions[i]; + var attr = action.GetType().GetCustomAttributes(typeof(ShortcutAttribute), true); + + foreach (ShortcutAttribute shortcut in attr) + { + if (shortcut.MatchesEvent(evt)) + { + if (s_ShowActionTriggeredByShortcut) + Debug.Log(action.GetType().Name); + + if (!action.IsActionActiveInMode(TimelineWindow.instance.currentMode.mode)) + continue; + + if (invoke(action)) + return true; + } + } + } + + return false; + } + + public static bool ExecuteTimelineAction(TimelineAction timelineAction, ActionContext context) + { + if (timelineAction.Validate(context) == ActionValidity.Valid) + { + if (timelineAction.HasAutoUndo()) + UndoExtensions.RegisterContext(context, timelineAction.GetUndoName()); + return timelineAction.Execute(context); + } + return false; + } + + public static bool ExecuteTrackAction(TrackAction trackAction, IEnumerable tracks) + { + if (tracks != null && tracks.Any() && trackAction.Validate(tracks) == ActionValidity.Valid) + { + if (trackAction.HasAutoUndo()) + UndoExtensions.RegisterTracks(tracks, trackAction.GetUndoName()); + return trackAction.Execute(tracks); + } + return false; + } + + public static bool ExecuteClipAction(ClipAction clipAction, IEnumerable clips) + { + if (clips != null && clips.Any() && clipAction.Validate(clips) == ActionValidity.Valid) + { + if (clipAction.HasAutoUndo()) + UndoExtensions.RegisterClips(clips, clipAction.GetUndoName()); + return clipAction.Execute(clips); + } + return false; + } + + public static bool ExecuteMarkerAction(MarkerAction markerAction, IEnumerable markers) + { + if (markers != null && markers.Any() && markerAction.Validate(markers) == ActionValidity.Valid) + { + if (markerAction.HasAutoUndo()) + UndoExtensions.RegisterMarkers(markers, markerAction.GetUndoName()); + return markerAction.Execute(markers); + } + return false; + } + + static List InstantiateClassesOfType() where T : class + { + var typeCollection = TypeCache.GetTypesDerivedFrom(typeof(T)); + var list = new List(typeCollection.Count); + for (int i = 0; i < typeCollection.Count; i++) + { + if (typeCollection[i].IsAbstract || typeCollection[i].IsGenericType) + continue; + + if (typeCollection[i].GetConstructor(Type.EmptyTypes) == null) + { + Debug.LogWarning($"{typeCollection[i].FullName} requires a default constructor to be automatically instantiated by Timeline"); + continue; + } + + list.Add((T)Activator.CreateInstance(typeCollection[i])); + } + return list; + } + + static List ActionsWithShortCuts(IReadOnlyList list) + { + return list.Where(x => x.GetType().GetCustomAttributes(typeof(ShortcutAttribute), true).Length > 0).ToList(); + } + + static HashSet TypesWithAttribute() where T : Attribute + { + var hashSet = new HashSet(); + var typeCollection = TypeCache.GetTypesWithAttribute(typeof(T)); + for (int i = 0; i < typeCollection.Count; i++) + { + hashSet.Add(typeCollection[i]); + } + + return hashSet; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ActionManager.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ActionManager.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..0251f525e4b06845e9354eff5ca1fcb12bbccdae --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ActionManager.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b185b14d428805c46aceb7c663825b2d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ClipAction.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ClipAction.cs new file mode 100644 index 0000000000000000000000000000000000000000..f335a82e45429b2427b6be5807a28d85246f47ff --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ClipAction.cs @@ -0,0 +1,36 @@ +using System.Collections.Generic; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Actions +{ + /// + /// Base class for a clip action. + /// Inherit from this class to make an action that would react on selected clips after a menu click and/or a key shortcut. + /// + /// + /// Simple Clip Action example (with context menu and shortcut support). + /// + /// + /// + /// To add an action as a menu item in the Timeline context menu, add on the action class. + /// To make an action to react to a shortcut, use the Shortcut Manager API with . + /// + /// + [ActiveInMode(TimelineModes.Default)] + public abstract class ClipAction : IAction + { + /// + /// Execute the action based on clips. + /// + /// clips that the action will act on. + /// Returns true if the action has been correctly executed, false otherwise. + public abstract bool Execute(IEnumerable clips); + + /// + /// Defines the validity of an Action for a given set of clips. + /// + /// The clips that the action will act on. + /// The validity of the set of clips. + public abstract ActionValidity Validate(IEnumerable clips); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ClipAction.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ClipAction.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..c1297b7b3ac6e64ba9f39fd5f0881d3b73645233 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ClipAction.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fa130a47ff26ad84f867961fc32334af +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ClipsActions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ClipsActions.cs new file mode 100644 index 0000000000000000000000000000000000000000..37f1d0875db9133ac25af3305210581b45a8ac9a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ClipsActions.cs @@ -0,0 +1,392 @@ +using System.Collections.Generic; +using System.Linq; +using JetBrains.Annotations; +using UnityEditor.Timeline.Actions; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + [MenuEntry("Edit in Animation Window", MenuPriority.ClipEditActionSection.editInAnimationWindow), UsedImplicitly] + class EditClipInAnimationWindow : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + if (!GetEditableClip(clips, out _, out _)) + return ActionValidity.NotApplicable; + return ActionValidity.Valid; + } + + public override bool Execute(IEnumerable 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; + } + + private static bool GetEditableClip(IEnumerable clips, out TimelineClip clip, out AnimationClip animClip) + { + clip = null; + animClip = null; + + if (clips.Count() != 1) + return false; + + clip = clips.FirstOrDefault(); + if (clip == null) + return false; + + if (clip.animationClip != null) + animClip = clip.animationClip; + else if (clip.curves != null && !clip.curves.empty) + animClip = clip.curves; + + return animClip != null; + } + } + + [MenuEntry("Edit Sub-Timeline", MenuPriority.ClipEditActionSection.editSubTimeline), UsedImplicitly] + class EditSubTimeline : ClipAction + { + private static readonly string MultiItemPrefix = "Edit Sub-Timelines/"; + private static readonly string SingleItemPrefix = "Edit "; + + public override ActionValidity Validate(IEnumerable clips) + { + if (clips == null || clips.Count() != 1 || TimelineEditor.inspectedDirector == null) + return ActionValidity.NotApplicable; + + var clip = clips.First(); + var directors = TimelineUtility.GetSubTimelines(clip, TimelineEditor.inspectedDirector); + return directors.Any(x => x != null) ? ActionValidity.Valid : ActionValidity.NotApplicable; + } + + public override bool Execute(IEnumerable clips) + { + if (Validate(clips) != ActionValidity.Valid) return false; + + var clip = clips.First(); + + var directors = TimelineUtility.GetSubTimelines(clip, TimelineEditor.inspectedDirector); + ExecuteInternal(directors, 0, clip); + + return true; + } + + static void ExecuteInternal(IList directors, int directorIndex, TimelineClip clip) + { + SelectionManager.Clear(); + TimelineWindow.instance.SetCurrentTimeline(directors[directorIndex], clip); + } + + internal void AddMenuItem(List menuItems) + { + var clips = TimelineEditor.selectedClips; + if (clips == null || clips.Length != 1) + return; + + var mode = TimelineWindow.instance.currentMode.mode; + MenuEntryAttribute menuAttribute = GetType().GetCustomAttributes(typeof(MenuEntryAttribute), false).OfType().FirstOrDefault(); + var menuItem = new MenuActionItem() + { + category = menuAttribute.subMenuPath ?? string.Empty, + entryName = menuAttribute.name, + isActiveInMode = this.IsActionActiveInMode(mode), + priority = menuAttribute.priority, + state = Validate(clips), + callback = null + }; + + var subDirectors = TimelineUtility.GetSubTimelines(clips[0], TimelineEditor.inspectedDirector); + if (subDirectors.Count == 1) + { + menuItem.entryName = SingleItemPrefix + DisplayNameHelper.GetDisplayName(subDirectors[0]); + menuItem.callback = () => + { + Execute(clips); + }; + menuItems.Add(menuItem); + } + else + { + for (int i = 0; i < subDirectors.Count; i++) + { + var index = i; + menuItem.category = MultiItemPrefix; + menuItem.entryName = DisplayNameHelper.GetDisplayName(subDirectors[i]); + menuItem.callback = () => + { + ExecuteInternal(subDirectors, index, clips[0]); + }; + menuItems.Add(menuItem); + } + } + } + } + + [MenuEntry("Editing/Trim Start", MenuPriority.ClipActionSection.trimStart)] + [Shortcut(Shortcuts.Clip.trimStart), UsedImplicitly] + class TrimStart : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + return clips.All(x => TimelineEditor.inspectedSequenceTime <= x.start || TimelineEditor.inspectedSequenceTime >= x.start + x.duration) ? ActionValidity.Invalid : ActionValidity.Valid; + } + + public override bool Execute(IEnumerable clips) + { + return ClipModifier.TrimStart(clips, TimelineEditor.inspectedSequenceTime); + } + } + + [MenuEntry("Editing/Trim End", MenuPriority.ClipActionSection.trimEnd), UsedImplicitly] + [Shortcut(Shortcuts.Clip.trimEnd)] + class TrimEnd : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + return clips.All(x => TimelineEditor.inspectedSequenceTime <= x.start || TimelineEditor.inspectedSequenceTime >= x.start + x.duration) ? ActionValidity.Invalid : ActionValidity.Valid; + } + + public override bool Execute(IEnumerable clips) + { + return ClipModifier.TrimEnd(clips, TimelineEditor.inspectedSequenceTime); + } + } + + [Shortcut(Shortcuts.Clip.split)] + [MenuEntry("Editing/Split", MenuPriority.ClipActionSection.split), UsedImplicitly] + class Split : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + return clips.All(x => TimelineEditor.inspectedSequenceTime <= x.start || TimelineEditor.inspectedSequenceTime >= x.start + x.duration) ? ActionValidity.Invalid : ActionValidity.Valid; + } + + public override bool Execute(IEnumerable clips) + { + bool success = ClipModifier.Split(clips, TimelineEditor.inspectedSequenceTime, TimelineEditor.inspectedDirector); + if (success) + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + return success; + } + } + + [MenuEntry("Editing/Complete Last Loop", MenuPriority.ClipActionSection.completeLastLoop), UsedImplicitly] + class CompleteLastLoop : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + bool canDisplay = clips.Any(TimelineHelpers.HasUsableAssetDuration); + return canDisplay ? ActionValidity.Valid : ActionValidity.Invalid; + } + + public override bool Execute(IEnumerable clips) + { + return ClipModifier.CompleteLastLoop(clips); + } + } + + [MenuEntry("Editing/Trim Last Loop", MenuPriority.ClipActionSection.trimLastLoop), UsedImplicitly] + class TrimLastLoop : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + bool canDisplay = clips.Any(TimelineHelpers.HasUsableAssetDuration); + return canDisplay ? ActionValidity.Valid : ActionValidity.Invalid; + } + + public override bool Execute(IEnumerable clips) + { + return ClipModifier.TrimLastLoop(clips); + } + } + + [MenuEntry("Editing/Match Duration", MenuPriority.ClipActionSection.matchDuration), UsedImplicitly] + class MatchDuration : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + return clips.Count() > 1 ? ActionValidity.Valid : ActionValidity.Invalid; + } + + public override bool Execute(IEnumerable clips) + { + return ClipModifier.MatchDuration(clips); + } + } + + [MenuEntry("Editing/Double Speed", MenuPriority.ClipActionSection.doubleSpeed), UsedImplicitly] + class DoubleSpeed : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + bool canDisplay = clips.All(x => x.SupportsSpeedMultiplier()); + + return canDisplay ? ActionValidity.Valid : ActionValidity.Invalid; + } + + public override bool Execute(IEnumerable clips) + { + return ClipModifier.DoubleSpeed(clips); + } + } + + [MenuEntry("Editing/Half Speed", MenuPriority.ClipActionSection.halfSpeed), UsedImplicitly] + class HalfSpeed : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + bool canDisplay = clips.All(x => x.SupportsSpeedMultiplier()); + + return canDisplay ? ActionValidity.Valid : ActionValidity.Invalid; + } + + public override bool Execute(IEnumerable clips) + { + return ClipModifier.HalfSpeed(clips); + } + } + + [MenuEntry("Editing/Reset Duration", MenuPriority.ClipActionSection.resetDuration), UsedImplicitly] + class ResetDuration : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + bool canDisplay = clips.Any(TimelineHelpers.HasUsableAssetDuration); + return canDisplay ? ActionValidity.Valid : ActionValidity.Invalid; + } + + public override bool Execute(IEnumerable clips) + { + return ClipModifier.ResetEditing(clips); + } + } + + [MenuEntry("Editing/Reset Speed", MenuPriority.ClipActionSection.resetSpeed), UsedImplicitly] + class ResetSpeed : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + bool canDisplay = clips.All(x => x.SupportsSpeedMultiplier()); + + return canDisplay ? ActionValidity.Valid : ActionValidity.Invalid; + } + + public override bool Execute(IEnumerable clips) + { + return ClipModifier.ResetSpeed(clips); + } + } + + [MenuEntry("Editing/Reset All", MenuPriority.ClipActionSection.resetAll), UsedImplicitly] + class ResetAll : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + bool canDisplay = clips.Any(TimelineHelpers.HasUsableAssetDuration) || clips.All(x => x.SupportsSpeedMultiplier()); + + return canDisplay ? ActionValidity.Valid : ActionValidity.Invalid; + } + + public override bool Execute(IEnumerable clips) + { + var speedResult = ClipModifier.ResetSpeed(clips); + var editResult = ClipModifier.ResetEditing(clips); + return speedResult || editResult; + } + } + + [MenuEntry("Tile", MenuPriority.ClipActionSection.tile), UsedImplicitly] + class Tile : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + return clips.Count() > 1 ? ActionValidity.Valid : ActionValidity.Invalid; + } + + public override bool Execute(IEnumerable clips) + { + return ClipModifier.Tile(clips); + } + } + + [MenuEntry("Find Source Asset", MenuPriority.ClipActionSection.findSourceAsset), UsedImplicitly] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class FindSourceAsset : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) + { + if (clips.Count() > 1) + return ActionValidity.Invalid; + + if (GetUnderlyingAsset(clips.First()) == null) + return ActionValidity.Invalid; + + return ActionValidity.Valid; + } + + public override bool Execute(IEnumerable clips) + { + EditorGUIUtility.PingObject(GetUnderlyingAsset(clips.First())); + return true; + } + + private static UnityEngine.Object GetExternalPlayableAsset(TimelineClip clip) + { + if (clip.asset == null) + return null; + + if ((clip.asset.hideFlags & HideFlags.HideInHierarchy) != 0) + return null; + + return clip.asset; + } + + private static UnityEngine.Object GetUnderlyingAsset(TimelineClip clip) + { + var asset = clip.asset as ScriptableObject; + if (asset == null) + return null; + + var fields = ObjectReferenceField.FindObjectReferences(asset.GetType()); + if (fields.Length == 0) + return GetExternalPlayableAsset(clip); + + // Find the first non-null field + foreach (var field in fields) + { + // skip scene refs in asset mode + if (TimelineEditor.inspectedDirector == null && field.isSceneReference) + continue; + var obj = field.Find(asset, TimelineEditor.inspectedDirector); + if (obj != null) + return obj; + } + + return GetExternalPlayableAsset(clip); + } + } + + class CopyClipsToClipboard : ClipAction + { + public override ActionValidity Validate(IEnumerable clips) => ActionValidity.Valid; + public override bool Execute(IEnumerable clips) + { + TimelineEditor.clipboard.CopyItems(clips.ToItems()); + return true; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ClipsActions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ClipsActions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..666f56eae67f9d3c96625f4d719340d1fe2cdab1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/ClipsActions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4b721099b5d509d4093e516f59ad9ad6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IAction.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IAction.cs new file mode 100644 index 0000000000000000000000000000000000000000..93090e443c2b3511b0cf36d230cb355413e06d00 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IAction.cs @@ -0,0 +1,123 @@ +using System; +using System.ComponentModel; +using System.Linq; +using System.Reflection; +using UnityEditor.ShortcutManagement; +using UnityEngine; + +namespace UnityEditor.Timeline.Actions +{ + /// interface indicating an Action class + interface IAction {} + + /// extension methods for IActions + static class ActionExtensions + { + const string kActionPostFix = "Action"; + + public static string GetUndoName(this IAction action) + { + if (action == null) + throw new ArgumentNullException(nameof(action)); + + var attr = action.GetType().GetCustomAttribute(false); + if (attr != null && !string.IsNullOrWhiteSpace(attr.UndoTitle)) + return attr.UndoTitle; + + return action.GetDisplayName(); + } + + public static string GetMenuEntryName(this IAction action) + { + var menuAction = action as IMenuName; + if (menuAction != null && !string.IsNullOrWhiteSpace(menuAction.menuName)) + return menuAction.menuName; + + var attr = action.GetType().GetCustomAttribute(false); + if (attr != null && !string.IsNullOrWhiteSpace(attr.name)) + return attr.name; + + return action.GetDisplayName(); + } + + public static string GetDisplayName(this IAction action) + { + if (action == null) + throw new ArgumentNullException(nameof(action)); + + var attr = action.GetType().GetCustomAttribute(false); + if (attr != null && !string.IsNullOrEmpty(attr.DisplayName)) + return attr.DisplayName; + + var name = action.GetType().Name; + if (name.EndsWith(kActionPostFix)) + return ObjectNames.NicifyVariableName(name.Substring(0, name.Length - kActionPostFix.Length)); + + return ObjectNames.NicifyVariableName(name); + } + + public static bool HasAutoUndo(this IAction action) + { + return action != null && ActionManager.ActionsWithAutoUndo.Contains(action.GetType()); + } + + public static bool IsChecked(this IAction action) + { + return (action is IMenuChecked menuAction) && menuAction.isChecked; + } + + public static bool IsActionActiveInMode(this IAction action, TimelineModes mode) + { + var attr = action.GetType().GetCustomAttribute(true); + return attr != null && (attr.modes & mode) != 0; + } + + public static string GetShortcut(this IAction action) + { + if (action == null) + throw new ArgumentNullException(nameof(action)); + + var shortcutAttribute = GetShortcutAttributeForAction(action); + var shortCut = shortcutAttribute == null ? string.Empty : shortcutAttribute.GetMenuShortcut(); + if (string.IsNullOrWhiteSpace(shortCut)) + { + //Check if there is a static method with attribute + var customShortcutMethod = action.GetType().GetMethods().FirstOrDefault(m => m.GetCustomAttribute(true) != null); + if (customShortcutMethod != null) + { + var shortcutId = customShortcutMethod.GetCustomAttribute(true).identifier; + var shortcut = ShortcutIntegration.instance.directory.FindShortcutEntry(shortcutId); + if (shortcut != null && shortcut.combinations.Any()) + shortCut = KeyCombination.SequenceToMenuString(shortcut.combinations); + } + } + + return shortCut; + } + + static ShortcutAttribute GetShortcutAttributeForAction(this IAction action) + { + if (action == null) + throw new ArgumentNullException(nameof(action)); + + var shortcutAttributes = action.GetType() + .GetCustomAttributes(typeof(ShortcutAttribute), true) + .Cast(); + + foreach (var shortcutAttribute in shortcutAttributes) + { + if (shortcutAttribute is ShortcutPlatformOverrideAttribute shortcutOverride) + { + if (shortcutOverride.MatchesCurrentPlatform()) + return shortcutOverride; + } + else + { + return shortcutAttribute; + } + } + + return null; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IAction.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IAction.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..6a74d37fba0a1c8fb9aa32ceff130d1bf02f3616 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IAction.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: de11c48878ba1b44b8b641af54dba8c1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IMenuChecked.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IMenuChecked.cs new file mode 100644 index 0000000000000000000000000000000000000000..e61005f27c37c9d4d3725bf54093c294c9909696 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IMenuChecked.cs @@ -0,0 +1,9 @@ +using System; + +namespace UnityEditor.Timeline +{ + interface IMenuChecked + { + bool isChecked { get; } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IMenuChecked.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IMenuChecked.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..0805a25af6ead877ed3805892d1b0f7b022207b5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IMenuChecked.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: 0939c83f40ef46e584340aa87b3cadfe +timeCreated: 1591130283 \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IMenuName.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IMenuName.cs new file mode 100644 index 0000000000000000000000000000000000000000..551f9362300958058df8fc10c62d7ec4f41d456f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IMenuName.cs @@ -0,0 +1,9 @@ +using System; + +namespace UnityEditor.Timeline +{ + interface IMenuName + { + string menuName { get; } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IMenuName.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IMenuName.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..3a9061ff61085b665c9eb89f53b62a38fe019cc2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/IMenuName.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: 512ac45650d443f3be59379c2ecbf068 +timeCreated: 1591130274 \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/Invoker.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/Invoker.cs new file mode 100644 index 0000000000000000000000000000000000000000..750d8cbac0f6ef6ad55973b2f0e0c274ee1b3d41 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/Invoker.cs @@ -0,0 +1,101 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Actions +{ + /// + /// Class containing methods to invoke actions. + /// + public static class Invoker + { + /// + /// Execute a given action with a context parameter. + /// + /// Action type to execute. + /// Context for the action. + /// True if the action has been executed, false otherwise. + public static bool Invoke(this ActionContext context) where T : TimelineAction + { + var action = ActionManager.TimelineActions.GetCachedAction(); + return ActionManager.ExecuteTimelineAction(action, context); + } + + /// + /// Execute a given action with tracks + /// + /// Action type to execute. + /// Tracks that the action will act on. + /// True if the action has been executed, false otherwise. + public static bool Invoke(this IEnumerable tracks) where T : TrackAction + { + var action = ActionManager.TrackActions.GetCachedAction(); + return ActionManager.ExecuteTrackAction(action, tracks); + } + + /// + /// Execute a given action with clips + /// + /// Action type to execute. + /// Clips that the action will act on. + /// True if the action has been executed, false otherwise. + public static bool Invoke(this IEnumerable clips) where T : ClipAction + { + var action = ActionManager.ClipActions.GetCachedAction(); + return ActionManager.ExecuteClipAction(action, clips); + } + + /// + /// Execute a given action with markers + /// + /// Action type to execute. + /// Markers that the action will act on. + /// True if the action has been executed, false otherwise. + public static bool Invoke(this IEnumerable markers) where T : MarkerAction + { + var action = ActionManager.MarkerActions.GetCachedAction(); + return ActionManager.ExecuteMarkerAction(action, markers); + } + + /// + /// Execute a given timeline action with the selected clips, tracks and markers. + /// + /// Action type to execute. + /// True if the action has been executed, false otherwise. + public static bool InvokeWithSelected() where T : TimelineAction + { + return Invoke(TimelineEditor.CurrentContext()); + } + + /// + /// Execute a given clip action with the selected clips. + /// + /// Action type to execute. + /// True if the action has been executed, false otherwise. + public static bool InvokeWithSelectedClips() where T : ClipAction + { + return Invoke(SelectionManager.SelectedClips()); + } + + /// + /// Execute a given track action with the selected tracks. + /// + /// Action type to execute. + /// True if the action has been executed, false otherwise. + public static bool InvokeWithSelectedTracks() where T : TrackAction + { + return Invoke(SelectionManager.SelectedTracks()); + } + + /// + /// Execute a given marker action with the selected markers. + /// + /// Action type to execute. + /// True if the action has been executed, false otherwise. + public static bool InvokeWithSelectedMarkers() where T : MarkerAction + { + return Invoke(SelectionManager.SelectedMarkers()); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/Invoker.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/Invoker.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..915cc0c5f1b95f82fac0e50540ffb60c590edc62 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/Invoker.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0c379d496c819c14b8b5377d7830a59a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/MarkerAction.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/MarkerAction.cs new file mode 100644 index 0000000000000000000000000000000000000000..76456b61fe8412ccec6e0c93178a3f170269550d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/MarkerAction.cs @@ -0,0 +1,35 @@ +using System.Collections.Generic; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Actions +{ + /// + /// Base class for a marker action. + /// Inherit from this class to make an action that would react on selected markers after a menu click and/or a key shortcut. + /// + /// + /// Simple track Action example (with context menu and shortcut support). + /// + /// + /// + /// To add an action as a menu item in the Timeline context menu, add on the action class. + /// To make an action to react to a shortcut, use the Shortcut Manager API with . + /// + /// + [ActiveInMode(TimelineModes.Default)] + public abstract class MarkerAction : IAction + { + /// + /// Execute the action. + /// + /// Markers that will be used for the action. + /// true if the action has been executed. false otherwise + public abstract bool Execute(IEnumerable markers); + /// + /// Defines the validity of an Action for a given set of markers. + /// + /// Markers that will be used for the action. + /// The validity of the set of markers. + public abstract ActionValidity Validate(IEnumerable markers); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/MarkerAction.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/MarkerAction.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..36ab3da7e32f8e141cbb39cad6068fc28ba76563 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/MarkerAction.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 03d19e545aea1b446b1c56530a4438ae +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/MarkerActions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/MarkerActions.cs new file mode 100644 index 0000000000000000000000000000000000000000..9c0f491afbb2a7a5141a3acab16fd1da4cd1f1aa --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/MarkerActions.cs @@ -0,0 +1,20 @@ +using System.Collections.Generic; +using JetBrains.Annotations; +using UnityEditor.Timeline.Actions; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [UsedImplicitly] + class CopyMarkersToClipboard : MarkerAction + { + public override ActionValidity Validate(IEnumerable markers) => ActionValidity.Valid; + + public override bool Execute(IEnumerable markers) + { + TimelineEditor.clipboard.CopyItems(markers.ToItems()); + return true; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/MarkerActions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/MarkerActions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..273304662ecc881b69af4ed10283296116bd321b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/MarkerActions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5da77d4d078922b4c8466e9e35fb3f5e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/Menus.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/Menus.meta new file mode 100644 index 0000000000000000000000000000000000000000..45d9fa7c653a035ba42a3711dfd7189004d08eac --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/Menus.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 985eed4bc2fbee941b761b8816d9055d +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TimelineAction.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TimelineAction.cs new file mode 100644 index 0000000000000000000000000000000000000000..3d6111449473a42c2ea7a56ac61a336c85a7f6df --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TimelineAction.cs @@ -0,0 +1,34 @@ +namespace UnityEditor.Timeline.Actions +{ + /// + /// Base class for a timeline action. + /// Inherit from this class to make an action on a timeline after a menu click and/or a key shortcut. + /// + /// + /// To add an action as a menu item in the Timeline context menu, add on the action class. + /// To make an action to react to a shortcut, use the Shortcut Manager API with . + /// + /// + /// + /// + /// Simple Timeline Action example (with context menu and shortcut support). + /// + /// + [ActiveInMode(TimelineModes.Default)] + public abstract class TimelineAction : IAction + { + /// + /// Execute the action. + /// + /// Context for the action. + /// true if the action has been executed. false otherwise + public abstract bool Execute(ActionContext context); + + /// + /// Defines the validity of an Action based on the context. + /// + /// Context for the action. + /// Visual state of the menu for the action. + public abstract ActionValidity Validate(ActionContext context); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TimelineAction.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TimelineAction.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2d295659c9b8847dd7a59e99df4edb7b1ad888e9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TimelineAction.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 38eaad816666dfb428c3f123a09413c6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TimelineActions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TimelineActions.cs new file mode 100644 index 0000000000000000000000000000000000000000..1fbb11913b0ad4dc5b83587dd091d0f83d9a3818 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TimelineActions.cs @@ -0,0 +1,918 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.ShortcutManagement; +using UnityEditor.Timeline.Actions; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [MenuEntry("Copy", MenuPriority.TimelineActionSection.copy)] + [Shortcut("Main Menu/Edit/Copy", EventCommandNames.Copy)] + class CopyAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) + { + return SelectionManager.Count() > 0 ? ActionValidity.Valid : ActionValidity.NotApplicable; + } + + public override bool Execute(ActionContext context) + { + TimelineEditor.clipboard.Clear(); + + var clips = context.clips; + if (clips.Any()) + { + clips.Invoke(); + } + var markers = context.markers; + if (markers.Any()) + { + markers.Invoke(); + } + var tracks = context.tracks; + if (tracks.Any()) + { + CopyTracksToClipboard.Do(tracks.ToArray()); + } + + return true; + } + } + + [MenuEntry("Paste", MenuPriority.TimelineActionSection.paste, MenuFilter.Default | MenuFilter.MarkerHeader)] + [Shortcut("Main Menu/Edit/Paste", EventCommandNames.Paste)] + class PasteAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) + { + return CanPaste(context.invocationTime) ? ActionValidity.Valid : ActionValidity.Invalid; + } + + public override bool Execute(ActionContext context) + { + if (!CanPaste(context.invocationTime)) + return false; + + PasteItems(context.invocationTime); + PasteTracks(); + + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + return true; + } + + static bool CanPaste(double? invocationTime) + { + var copiedItems = TimelineEditor.clipboard.GetCopiedItems().ToList(); + + if (!copiedItems.Any()) + return TimelineEditor.clipboard.GetTracks().Any(); + + return CanPasteItems(copiedItems, invocationTime); + } + + static bool CanPasteItems(ICollection itemsGroups, double? invocationTime) + { + var hasItemsCopiedFromMultipleTracks = itemsGroups.Count > 1; + var allItemsCopiedFromCurrentAsset = itemsGroups.All(x => x.targetTrack.timelineAsset == TimelineEditor.inspectedAsset); + var hasUsedShortcut = invocationTime == null; + var anySourceLocked = itemsGroups.Any(x => x.targetTrack != null && x.targetTrack.lockedInHierarchy); + + var targetTrack = GetPickedTrack(); + if (targetTrack == null) + targetTrack = SelectionManager.SelectedTracks().FirstOrDefault(); + + //do not paste if the user copied items from another timeline + //if the copied items comes from > 1 track (since we do not know where to paste the copied items) + //or if a keyboard shortcut was used (since the user will not see the paste result) + if (!allItemsCopiedFromCurrentAsset) + { + var isSelectedTrackInCurrentAsset = targetTrack != null && targetTrack.timelineAsset == TimelineEditor.inspectedAsset; + if (hasItemsCopiedFromMultipleTracks || (hasUsedShortcut && !isSelectedTrackInCurrentAsset)) + return false; + } + + // pasting to items to their source track, if items from multiple tracks are selected + // and no track is in the selection items will each be pasted to their respective track. + if (targetTrack==null || itemsGroups.All(x => x.targetTrack == targetTrack)) + return !anySourceLocked; + + if (hasItemsCopiedFromMultipleTracks) + { + //do not paste if the track which received the paste action does not contain a copied clip + return !anySourceLocked && itemsGroups.Select(x => x.targetTrack).Contains(targetTrack); + } + + var copiedItems = itemsGroups.SelectMany(i => i.items); + return IsTrackValidForItems(targetTrack, copiedItems); + } + + static void PasteItems(double? invocationTime) + { + var copiedItems = TimelineEditor.clipboard.GetCopiedItems().ToList(); + var numberOfUniqueParentsInClipboard = copiedItems.Count(); + + if (numberOfUniqueParentsInClipboard == 0) return; + List newItems; + + //if the copied items were on a single parent, then use the mouse position to get the parent OR the original parent + if (numberOfUniqueParentsInClipboard == 1) + { + var itemsGroup = copiedItems.First(); + TrackAsset target = null; + if (invocationTime.HasValue) + target = GetPickedTrack(); + if (target == null) + target = FindSuitableParentForSingleTrackPasteWithoutMouse(itemsGroup); + + var candidateTime = invocationTime ?? TimelineHelpers.GetCandidateTime(null, target); + newItems = TimelineHelpers.DuplicateItemsUsingCurrentEditMode(TimelineEditor.clipboard.exposedPropertyTable, TimelineEditor.inspectedDirector, itemsGroup, target, candidateTime, "Paste Items").ToList(); + } + //if copied items were on multiple parents, then the destination parents are the same as the original parents + else + { + var time = invocationTime ?? TimelineHelpers.GetCandidateTime(null, copiedItems.Select(c => c.targetTrack).ToArray()); + newItems = TimelineHelpers.DuplicateItemsUsingCurrentEditMode(TimelineEditor.clipboard.exposedPropertyTable, TimelineEditor.inspectedDirector, copiedItems, time, "Paste Items").ToList(); + } + + TimelineHelpers.FrameItems(newItems); + SelectionManager.RemoveTimelineSelection(); + foreach (var item in newItems) + { + SelectionManager.Add(item); + } + } + + static TrackAsset FindSuitableParentForSingleTrackPasteWithoutMouse(ItemsPerTrack itemsGroup) + { + var groupParent = itemsGroup.targetTrack; //set a main parent in the clipboard + var selectedTracks = SelectionManager.SelectedTracks(); + + if (selectedTracks.Contains(groupParent)) + { + return groupParent; + } + + //find a selected track suitable for all items + var itemsToPaste = itemsGroup.items; + var compatibleTrack = selectedTracks.FirstOrDefault(t => IsTrackValidForItems(t, itemsToPaste)); + return compatibleTrack != null ? compatibleTrack : groupParent; + } + + static bool IsTrackValidForItems(TrackAsset track, IEnumerable items) + { + if (track == null || track.lockedInHierarchy) return false; + return items.All(i => i.IsCompatibleWithTrack(track)); + } + + static TrackAsset GetPickedTrack() + { + if (PickerUtils.pickedElements == null) + return null; + + var rowGUI = PickerUtils.pickedElements.OfType().FirstOrDefault(); + if (rowGUI != null) + return rowGUI.asset; + + return null; + } + + static void PasteTracks() + { + var trackData = TimelineEditor.clipboard.GetTracks().ToList(); + if (trackData.Any()) + { + SelectionManager.RemoveTimelineSelection(); + } + + foreach (var track in trackData) + { + var newTrack = track.item.Duplicate(TimelineEditor.clipboard.exposedPropertyTable, TimelineEditor.inspectedDirector, TimelineEditor.inspectedAsset); + if (track.binding != null) + { + TimelineHelpers.Bind(newTrack, track.binding, TimelineEditor.inspectedDirector); + } + + SelectionManager.Add(newTrack); + foreach (var childTrack in newTrack.GetFlattenedChildTracks()) + { + SelectionManager.Add(childTrack); + } + + if (track.parent != null && track.parent.timelineAsset == TimelineEditor.inspectedAsset) + { + TrackExtensions.ReparentTracks(new List { newTrack }, track.parent, track.item); + } + } + } + } + + [MenuEntry("Duplicate", MenuPriority.TimelineActionSection.duplicate)] + [Shortcut("Main Menu/Edit/Duplicate", EventCommandNames.Duplicate)] + class DuplicateAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) + { + return context.clips.Any() || context.tracks.Any() || context.markers.Any() ? ActionValidity.Valid : ActionValidity.NotApplicable; + } + + public bool Execute(Func gapBetweenItems) + { + return Execute(TimelineEditor.CurrentContext(), gapBetweenItems); + } + + public override bool Execute(ActionContext context) + { + return Execute(context, (item1, item2) => ItemsUtils.TimeGapBetweenItems(item1, item2)); + } + + internal bool Execute(ActionContext context, Func gapBetweenItems) + { + List items = new List(); + items.AddRange(context.clips.Select(p => p.ToItem())); + items.AddRange(context.markers.Select(p => p.ToItem())); + List selectedItems = items.ToItemsPerTrack().ToList(); + if (selectedItems.Any()) + { + var requestedTime = CalculateDuplicateTime(selectedItems, gapBetweenItems); + var duplicatedItems = TimelineHelpers.DuplicateItemsUsingCurrentEditMode(TimelineEditor.inspectedDirector, TimelineEditor.inspectedDirector, selectedItems, requestedTime, "Duplicate Items"); + + TimelineHelpers.FrameItems(duplicatedItems); + SelectionManager.RemoveTimelineSelection(); + foreach (var item in duplicatedItems) + SelectionManager.Add(item); + } + + var tracks = context.tracks.ToArray(); + if (tracks.Length > 0) + tracks.Invoke(); + + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + return true; + } + + static double CalculateDuplicateTime(IEnumerable duplicatedItems, Func gapBetweenItems) + { + //Find the end time of the rightmost item + var itemsOnTracks = duplicatedItems.SelectMany(i => i.targetTrack.GetItems()).ToList(); + var time = itemsOnTracks.Max(i => i.end); + + //From all the duplicated items, select the leftmost items + var firstDuplicatedItems = duplicatedItems.Select(i => i.leftMostItem); + var leftMostDuplicatedItems = firstDuplicatedItems.OrderBy(i => i.start).GroupBy(i => i.start).FirstOrDefault(); + if (leftMostDuplicatedItems == null) return 0.0; + + foreach (var leftMostItem in leftMostDuplicatedItems) + { + var siblings = leftMostItem.parentTrack.GetItems(); + var rightMostSiblings = siblings.OrderByDescending(i => i.end).GroupBy(i => i.end).FirstOrDefault(); + if (rightMostSiblings == null) continue; + + foreach (var sibling in rightMostSiblings) + time = Math.Max(time, sibling.end + gapBetweenItems(leftMostItem, sibling)); + } + + return time; + } + } + + [MenuEntry("Delete", MenuPriority.TimelineActionSection.delete)] + [Shortcut("Main Menu/Edit/Delete", EventCommandNames.Delete)] + [ShortcutPlatformOverride(RuntimePlatform.OSXEditor, KeyCode.Backspace, ShortcutModifiers.Action)] + [ActiveInMode(TimelineModes.Default)] + class DeleteAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) + { + return CanDelete(context) ? ActionValidity.Valid : ActionValidity.Invalid; + } + + static bool CanDelete(ActionContext context) + { + if (TimelineWindow.instance.state.editSequence.isReadOnly) + return false; + // All() returns true when empty + return context.tracks.All(x => !x.lockedInHierarchy) && + context.clips.All(x => x.parentTrack == null || !x.parentTrack.lockedInHierarchy) && + context.markers.All(x => x.parent == null || !x.parent.lockedInHierarchy); + } + + public override bool Execute(ActionContext context) + { + if (!CanDelete(context)) + return false; + + var selectedItems = context.clips.Select(p => p.ToItem()).ToList(); + selectedItems.AddRange(context.markers.Select(p => p.ToItem())); + DeleteItems(selectedItems); + + if (context.tracks.Any() && SelectionManager.GetCurrentInlineEditorCurve() == null) + context.tracks.Invoke(); + + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + return selectedItems.Any() || context.tracks.Any(); + } + + internal static void DeleteItems(IEnumerable items) + { + var tracks = items.GroupBy(c => c.parentTrack); + + foreach (var track in tracks) + TimelineUndo.PushUndo(track.Key, "Delete Items"); + + TimelineAnimationUtilities.UnlinkAnimationWindowFromClips(items.OfType().Select(i => i.clip)); + + EditMode.PrepareItemsDelete(ItemsUtils.ToItemsPerTrack(items)); + EditModeUtils.Delete(items); + + SelectionManager.RemoveAllClips(); + } + } + + [MenuEntry("Match Content", MenuPriority.TimelineActionSection.matchContent)] + [Shortcut(Shortcuts.Timeline.matchContent)] + class MatchContent : TimelineAction + { + public override ActionValidity Validate(ActionContext actionContext) + { + var clips = actionContext.clips; + + if (!clips.Any()) + return ActionValidity.NotApplicable; + + return clips.Any(TimelineHelpers.HasUsableAssetDuration) + ? ActionValidity.Valid + : ActionValidity.Invalid; + } + + public override bool Execute(ActionContext actionContext) + { + var clips = actionContext.clips; + return clips.Any() && ClipModifier.MatchContent(clips); + } + } + + [Shortcut(Shortcuts.Timeline.play)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class PlayTimelineAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + var currentState = TimelineEditor.state.playing; + TimelineEditor.state.SetPlaying(!currentState); + return true; + } + } + + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class SelectAllAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + // otherwise select all tracks. + SelectionManager.Clear(); + TimelineWindow.instance.allTracks.ForEach(x => SelectionManager.Add(x.track)); + return true; + } + } + + [Shortcut(Shortcuts.Timeline.previousFrame)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class PreviousFrameAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + if (TimelineEditor.inspectedAsset == null) + return false; + var inspectedFrame = TimeUtility.ToFrames(TimelineEditor.inspectedSequenceTime, TimelineEditor.inspectedAsset.editorSettings.fps); + inspectedFrame = Mathf.Max(0, inspectedFrame - 1); + TimelineEditor.inspectedSequenceTime = TimeUtility.FromFrames(inspectedFrame, TimelineEditor.inspectedAsset.editorSettings.fps); + return true; + } + } + + [Shortcut(Shortcuts.Timeline.nextFrame)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class NextFrameAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + if (TimelineEditor.inspectedAsset == null) + return false; + var inspectedFrame = TimeUtility.ToFrames(TimelineEditor.inspectedSequenceTime, TimelineEditor.inspectedAsset.editorSettings.fps); + inspectedFrame++; + TimelineEditor.inspectedSequenceTime = TimeUtility.FromFrames(inspectedFrame, TimelineEditor.inspectedAsset.editorSettings.fps); + return true; + } + } + + [Shortcut(Shortcuts.Timeline.frameAll)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class FrameAllAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) + { + if (context.timeline != null && !context.timeline.flattenedTracks.Any()) + return ActionValidity.NotApplicable; + + return ActionValidity.Valid; + } + + public override bool Execute(ActionContext actionContext) + { + var inlineCurveEditor = SelectionManager.GetCurrentInlineEditorCurve(); + if (FrameSelectedAction.ShouldHandleInlineCurve(inlineCurveEditor)) + { + FrameSelectedAction.FrameInlineCurves(inlineCurveEditor, false); + return true; + } + + if (TimelineWindow.instance.state.IsCurrentEditingASequencerTextField()) + return false; + + var visibleTracks = TimelineWindow.instance.treeView.visibleTracks.ToList(); + + if (TimelineEditor.inspectedAsset != null && TimelineEditor.inspectedAsset.markerTrack != null) + visibleTracks.Add(TimelineEditor.inspectedAsset.markerTrack); + + if (visibleTracks.Count == 0) + return false; + + var startTime = float.MaxValue; + var endTime = float.MinValue; + + foreach (var t in visibleTracks) + { + if (t == null) + continue; + + // time range based on track's curves and clips. + double trackStart, trackEnd, trackDuration; + t.GetSequenceTime(out trackStart, out trackDuration); + trackEnd = trackStart + trackDuration; + + // take track's markers into account + double itemsStart, itemsEnd; + ItemsUtils.GetItemRange(t, out itemsStart, out itemsEnd); + + startTime = Mathf.Min(startTime, (float)trackStart, (float)itemsStart); + endTime = Mathf.Max(endTime, (float)(trackEnd), (float)itemsEnd); + } + + FrameSelectedAction.FrameRange(startTime, endTime); + return true; + } + } + + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class FrameSelectedAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public static void FrameRange(float startTime, float endTime) + { + if (startTime > endTime) + { + return; + } + + var halfDuration = endTime - Math.Max(0.0f, startTime); + + if (halfDuration > 0.0f) + { + TimelineEditor.visibleTimeRange = new Vector2(Mathf.Max(0.0f, startTime - (halfDuration * 0.1f)), endTime + (halfDuration * 0.1f)); + } + else + { + // start == end + // keep the zoom level constant, only pan the time area to center the item + var currentRange = TimelineEditor.visibleTimeRange.y - TimelineEditor.visibleTimeRange.x; + TimelineEditor.visibleTimeRange = new Vector2(startTime - currentRange / 2, startTime + currentRange / 2); + } + + TimelineZoomManipulator.InvalidateWheelZoom(); + TimelineEditor.Refresh(RefreshReason.SceneNeedsUpdate); + } + + public override bool Execute(ActionContext actionContext) + { + var inlineCurveEditor = SelectionManager.GetCurrentInlineEditorCurve(); + if (ShouldHandleInlineCurve(inlineCurveEditor)) + { + FrameInlineCurves(inlineCurveEditor, true); + return true; + } + + if (TimelineWindow.instance.state.IsCurrentEditingASequencerTextField()) + return false; + + if (SelectionManager.Count() == 0) + { + actionContext.Invoke(); + return true; + } + + var startTime = float.MaxValue; + var endTime = float.MinValue; + + var clips = actionContext.clips.Select(ItemToItemGui.GetGuiForClip); + var markers = actionContext.markers; + if (!clips.Any() && !markers.Any()) + return false; + + foreach (var c in clips) + { + startTime = Mathf.Min(startTime, (float)c.clip.start); + endTime = Mathf.Max(endTime, (float)c.clip.end); + if (c.clipCurveEditor != null) + { + c.clipCurveEditor.FrameClip(); + } + } + + foreach (var marker in markers) + { + startTime = Mathf.Min(startTime, (float)marker.time); + endTime = Mathf.Max(endTime, (float)marker.time); + } + + FrameRange(startTime, endTime); + + return true; + } + + public static bool ShouldHandleInlineCurve(IClipCurveEditorOwner curveEditorOwner) + { + return curveEditorOwner?.clipCurveEditor != null && + curveEditorOwner.inlineCurvesSelected && + curveEditorOwner.owner != null && + curveEditorOwner.owner.GetShowInlineCurves(); + } + + public static void FrameInlineCurves(IClipCurveEditorOwner curveEditorOwner, bool selectionOnly) + { + var curveEditor = curveEditorOwner.clipCurveEditor.curveEditor; + var frameBounds = selectionOnly ? curveEditor.GetSelectionBounds() : curveEditor.GetClipBounds(); + + var clipGUI = curveEditorOwner as TimelineClipGUI; + var areaOffset = 0.0f; + + if (clipGUI != null) + { + areaOffset = (float)Math.Max(0.0, clipGUI.clip.FromLocalTimeUnbound(0.0)); + + var timeScale = (float)clipGUI.clip.timeScale; // Note: The getter for clip.timeScale is guaranteed to never be zero. + + // Apply scaling + var newMin = frameBounds.min.x / timeScale; + var newMax = (frameBounds.max.x - frameBounds.min.x) / timeScale + newMin; + + frameBounds.SetMinMax( + new Vector3(newMin, frameBounds.min.y, frameBounds.min.z), + new Vector3(newMax, frameBounds.max.y, frameBounds.max.z)); + } + + curveEditor.Frame(frameBounds, true, true); + + var area = curveEditor.shownAreaInsideMargins; + area.x += areaOffset; + + var curveStart = curveEditorOwner.clipCurveEditor.dataSource.start; + FrameRange(curveStart + frameBounds.min.x, curveStart + frameBounds.max.x); + } + } + + [Shortcut(Shortcuts.Timeline.previousKey)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class PrevKeyAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + if (TimelineEditor.inspectedAsset == null) + return false; + var keyTraverser = new Utilities.KeyTraverser(TimelineEditor.inspectedAsset, 0.01f / TimelineEditor.inspectedAsset.editorSettings.fps); + var time = keyTraverser.GetPrevKey((float)TimelineEditor.inspectedSequenceTime, TimelineWindow.instance.state.dirtyStamp); + if (time != TimelineEditor.inspectedSequenceTime) + { + TimelineEditor.inspectedSequenceTime = time; + } + + return true; + } + } + + [Shortcut(Shortcuts.Timeline.nextKey)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class NextKeyAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + if (TimelineEditor.inspectedAsset == null) + return false; + var keyTraverser = new Utilities.KeyTraverser(TimelineEditor.inspectedAsset, 0.01f / TimelineEditor.inspectedAsset.editorSettings.fps); + var time = keyTraverser.GetNextKey((float)TimelineEditor.inspectedSequenceTime, TimelineWindow.instance.state.dirtyStamp); + if (time != TimelineEditor.inspectedSequenceTime) + { + TimelineEditor.inspectedSequenceTime = time; + } + + return true; + } + } + + [Shortcut(Shortcuts.Timeline.goToStart)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class GotoStartAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + TimelineEditor.inspectedSequenceTime = 0.0f; + TimelineWindow.instance.state.EnsurePlayHeadIsVisible(); + + return true; + } + } + + [Shortcut(Shortcuts.Timeline.goToEnd)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class GotoEndAction : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + TimelineEditor.inspectedSequenceTime = TimelineWindow.instance.state.editSequence.duration; + TimelineWindow.instance.state.EnsurePlayHeadIsVisible(); + + return true; + } + } + + [Shortcut(Shortcuts.Timeline.zoomIn)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class ZoomIn : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + TimelineZoomManipulator.Instance.DoZoom(1.15f); + return true; + } + } + + [Shortcut(Shortcuts.Timeline.zoomOut)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class ZoomOut : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + TimelineZoomManipulator.Instance.DoZoom(0.85f); + return true; + } + } + + [Shortcut(Shortcuts.Timeline.collapseGroup)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class CollapseGroup : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + return KeyboardNavigation.CollapseGroup(actionContext.tracks); + } + } + + [Shortcut(Shortcuts.Timeline.unCollapseGroup)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class UnCollapseGroup : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + return KeyboardNavigation.UnCollapseGroup(actionContext.tracks); + } + } + + [Shortcut(Shortcuts.Timeline.selectLeftItem)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class SelectLeftClip : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + // Switches to track header if no left track exists + return KeyboardNavigation.SelectLeftItem(); + } + } + + [Shortcut(Shortcuts.Timeline.selectRightItem)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class SelectRightClip : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + return KeyboardNavigation.SelectRightItem(); + } + } + + [Shortcut(Shortcuts.Timeline.selectUpItem)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class SelectUpClip : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + return KeyboardNavigation.SelectUpItem(); + } + } + + [Shortcut(Shortcuts.Timeline.selectUpTrack)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class SelectUpTrack : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + return KeyboardNavigation.SelectUpTrack(); + } + } + + [Shortcut(Shortcuts.Timeline.selectDownItem)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class SelectDownClip : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + return KeyboardNavigation.SelectDownItem(); + } + } + + [Shortcut(Shortcuts.Timeline.selectDownTrack)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class SelectDownTrack : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + if (!KeyboardNavigation.ClipAreaActive() && !KeyboardNavigation.TrackHeadActive()) + return KeyboardNavigation.FocusFirstVisibleItem(); + else + return KeyboardNavigation.SelectDownTrack(); + } + } + + [Shortcut(Shortcuts.Timeline.multiSelectLeft)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class MultiselectLeftClip : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + return KeyboardNavigation.SelectLeftItem(true); + } + } + + [Shortcut(Shortcuts.Timeline.multiSelectRight)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class MultiselectRightClip : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + return KeyboardNavigation.SelectRightItem(true); + } + } + + [Shortcut(Shortcuts.Timeline.multiSelectUp)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class MultiselectUpTrack : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + return KeyboardNavigation.SelectUpTrack(true); + } + } + + [Shortcut(Shortcuts.Timeline.multiSelectDown)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class MultiselectDownTrack : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext actionContext) + { + return KeyboardNavigation.SelectDownTrack(true); + } + } + + [Shortcut(Shortcuts.Timeline.toggleClipTrackArea)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class ToggleClipTrackArea : TimelineAction + { + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + + public override bool Execute(ActionContext actionContext) + { + if (KeyboardNavigation.TrackHeadActive()) + return KeyboardNavigation.FocusFirstVisibleItem(actionContext.tracks); + + if (!KeyboardNavigation.ClipAreaActive()) + return KeyboardNavigation.FocusFirstVisibleItem(); + + var item = KeyboardNavigation.GetVisibleSelectedItems().LastOrDefault(); + if (item != null) + SelectionManager.SelectOnly(item.parentTrack); + return true; + } + } + + [MenuEntry("Mute Timeline Markers", MenuPriority.TrackActionSection.mute, MenuFilter.MarkerHeader)] + class ToggleMuteMarkersOnTimeline : TimelineAction, IMenuChecked + { + public bool isChecked + { + get => IsMarkerTrackValid() && TimelineEditor.inspectedAsset.markerTrack.muted; + } + + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + + public override bool Execute(ActionContext actionContext) + { + if (TimelineEditor.state.showMarkerHeader) + ToggleMute(); + return true; + } + + static void ToggleMute() + { + var timeline = TimelineEditor.inspectedAsset; + timeline.CreateMarkerTrack(); + + TimelineUndo.PushUndo(timeline.markerTrack, "Toggle Mute"); + timeline.markerTrack.muted = !timeline.markerTrack.muted; + } + + static bool IsMarkerTrackValid() + { + var timeline = TimelineEditor.inspectedAsset; + return timeline != null && timeline.markerTrack != null; + } + } + + [MenuEntry("Show Timeline Markers", MenuPriority.TrackActionSection.showHideMarkers, MenuFilter.MarkerHeader)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class ToggleShowMarkersOnTimeline : TimelineAction, IMenuChecked + { + public bool isChecked + { + get => TimelineEditor.state.showMarkerHeader; + } + + public override ActionValidity Validate(ActionContext context) => ActionValidity.Valid; + + public override bool Execute(ActionContext context) + { + ToggleShow(); + return true; + } + + static void ToggleShow() + { + TimelineEditor.state.showMarkerHeader = !TimelineEditor.state.showMarkerHeader; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TimelineActions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TimelineActions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..39295c49b26eb3a7b3c89ce5da000b492dbf24d0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TimelineActions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b1c789407b55e3a4c9cc86135a714e33 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TrackAction.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TrackAction.cs new file mode 100644 index 0000000000000000000000000000000000000000..038864801304e8b6ab2392e12746d94f1d2bcb1a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TrackAction.cs @@ -0,0 +1,36 @@ +using System.Collections.Generic; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Actions +{ + /// + /// Base class for a track action. + /// Inherit from this class to make an action that would react on selected tracks after a menu click and/or a key shortcut. + /// + /// + /// Simple track Action example (with context menu and shortcut support). + /// + /// + /// + /// To add an action as a menu item in the Timeline context menu, add on the action class. + /// To make an action to react to a shortcut, use the Shortcut Manager API with . + /// + /// + [ActiveInMode(TimelineModes.Default)] + public abstract class TrackAction : IAction + { + /// + /// Execute the action. + /// + /// Tracks that will be used for the action. + /// true if the action has been executed. false otherwise + public abstract bool Execute(IEnumerable tracks); + + /// + /// Defines the validity of an Action for a given set of tracks. + /// + /// tracks that the action would act on. + /// The validity of the set of tracks. + public abstract ActionValidity Validate(IEnumerable tracks); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TrackAction.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TrackAction.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..9fa038a8fc08a6a8d827eef580cf57e20df053f5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TrackAction.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bcac94f4ceb0c8049bf47480708ca7e2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TrackActions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TrackActions.cs new file mode 100644 index 0000000000000000000000000000000000000000..7a00bdfcf51b3da9597058e7da011fa22f19c159 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TrackActions.cs @@ -0,0 +1,451 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using JetBrains.Annotations; +using UnityEditor.Timeline.Actions; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [MenuEntry("Edit in Animation Window", MenuPriority.TrackActionSection.editInAnimationWindow)] + class EditTrackInAnimationWindow : TrackAction + { + 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; + } + + public override ActionValidity Validate(IEnumerable tracks) + { + if (!tracks.Any()) + return ActionValidity.Invalid; + + var firstTrack = tracks.First(); + if (firstTrack is AnimationTrack) + { + var animTrack = firstTrack as AnimationTrack; + if (animTrack.CanConvertToClipMode()) + return ActionValidity.Valid; + } + else if (firstTrack.hasCurves) + { + return ActionValidity.Valid; + } + + return ActionValidity.NotApplicable; + } + + public override bool Execute(IEnumerable tracks) + { + return Do(tracks.First()); + } + + static TimelineWindowTimeControl.ClipData CreateTimeControlClipData(TrackAsset track) + { + var data = new TimelineWindowTimeControl.ClipData(); + data.track = track; + data.start = track.start; + data.duration = track.duration; + return data; + } + } + + [MenuEntry("Lock selected track only", MenuPriority.TrackActionSection.lockSelected)] + class LockSelectedTrack : TrackAction, IMenuName + { + public static readonly string LockSelectedTrackOnlyText = L10n.Tr("Lock selected track only"); + public static readonly string UnlockSelectedTrackOnlyText = L10n.Tr("Unlock selected track only"); + + public string menuName { get; private set; } + + public override ActionValidity Validate(IEnumerable tracks) + { + UpdateMenuName(tracks); + if (tracks.Any(track => TimelineUtility.IsLockedFromGroup(track) || track is GroupTrack || !track.subTracksObjects.Any())) + return ActionValidity.NotApplicable; + return ActionValidity.Valid; + } + + public override bool Execute(IEnumerable tracks) + { + if (!tracks.Any()) return false; + + var hasUnlockedTracks = tracks.Any(x => !x.locked); + Lock(tracks.Where(p => !(p is GroupTrack)).ToArray(), hasUnlockedTracks); + return true; + } + + void UpdateMenuName(IEnumerable tracks) + { + menuName = tracks.All(t => t.locked) ? UnlockSelectedTrackOnlyText : LockSelectedTrackOnlyText; + } + + public static void Lock(TrackAsset[] tracks, bool shouldlock) + { + if (tracks.Length == 0) + return; + + foreach (var track in tracks.Where(t => !TimelineUtility.IsLockedFromGroup(t))) + { + TimelineUndo.PushUndo(track, "Lock Tracks"); + track.locked = shouldlock; + } + TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw); + } + } + + [MenuEntry("Lock", MenuPriority.TrackActionSection.lockTrack)] + [Shortcut(Shortcuts.Timeline.toggleLock)] + class LockTrack : TrackAction, IMenuName + { + static readonly string k_LockText = L10n.Tr("Lock"); + static readonly string k_UnlockText = L10n.Tr("Unlock"); + + public string menuName { get; private set; } + + + void UpdateMenuName(IEnumerable tracks) + { + menuName = tracks.Any(x => !x.locked) ? k_LockText : k_UnlockText; + } + + public override bool Execute(IEnumerable tracks) + { + if (!tracks.Any()) return false; + + var hasUnlockedTracks = tracks.Any(x => !x.locked); + SetLockState(tracks, hasUnlockedTracks); + return true; + } + + public override ActionValidity Validate(IEnumerable tracks) + { + UpdateMenuName(tracks); + if (tracks.Any(TimelineUtility.IsLockedFromGroup)) + return ActionValidity.Invalid; + return ActionValidity.Valid; + } + + public static void SetLockState(IEnumerable tracks, bool shouldLock) + { + if (!tracks.Any()) + return; + + foreach (var track in tracks) + { + if (TimelineUtility.IsLockedFromGroup(track)) + continue; + + if (track as GroupTrack == null) + SetLockState(track.GetChildTracks().ToArray(), shouldLock); + + TimelineUndo.PushUndo(track, "Lock Tracks"); + track.locked = shouldLock; + } + + // find the tracks we've locked. unselect anything locked and remove recording. + foreach (var track in tracks) + { + if (TimelineUtility.IsLockedFromGroup(track) || !track.locked) + continue; + + var flattenedChildTracks = track.GetFlattenedChildTracks(); + foreach (var i in track.clips) + SelectionManager.Remove(i); + track.UnarmForRecord(); + foreach (var child in flattenedChildTracks) + { + SelectionManager.Remove(child); + child.UnarmForRecord(); + foreach (var clip in child.GetClips()) + SelectionManager.Remove(clip); + } + } + + // no need to rebuild, just repaint (including inspectors) + InspectorWindow.RepaintAllInspectors(); + TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw); + } + } + + [UsedImplicitly] + [MenuEntry("Show Markers", MenuPriority.TrackActionSection.showHideMarkers)] + [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)] + class ShowHideMarkers : TrackAction, IMenuChecked + { + public bool isChecked { get; private set; } + + void UpdateCheckedStatus(IEnumerable tracks) + { + isChecked = tracks.All(x => x.GetShowMarkers()); + } + + public override ActionValidity Validate(IEnumerable tracks) + { + UpdateCheckedStatus(tracks); + if (tracks.Any(x => x is GroupTrack) || tracks.Any(t => t.GetMarkerCount() == 0)) + return ActionValidity.NotApplicable; + + if (tracks.Any(t => t.lockedInHierarchy)) + { + return ActionValidity.Invalid; + } + + return ActionValidity.Valid; + } + + public override bool Execute(IEnumerable tracks) + { + if (!tracks.Any()) return false; + + var hasUnlockedTracks = tracks.Any(x => !x.GetShowMarkers()); + ShowHide(tracks, hasUnlockedTracks); + return true; + } + + static void ShowHide(IEnumerable tracks, bool shouldLock) + { + if (!tracks.Any()) + return; + + foreach (var track in tracks) + track.SetShowTrackMarkers(shouldLock); + + TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw); + } + } + + [MenuEntry("Mute selected track only", MenuPriority.TrackActionSection.muteSelected), UsedImplicitly] + class MuteSelectedTrack : TrackAction, IMenuName + { + public static readonly string MuteSelectedText = L10n.Tr("Mute selected track only"); + public static readonly string UnmuteSelectedText = L10n.Tr("Unmute selected track only"); + + public string menuName { get; private set; } + + public override ActionValidity Validate(IEnumerable tracks) + { + UpdateMenuName(tracks); + if (tracks.Any(track => TimelineUtility.IsParentMuted(track) || track is GroupTrack || !track.subTracksObjects.Any())) + return ActionValidity.NotApplicable; + return ActionValidity.Valid; + } + + public override bool Execute(IEnumerable tracks) + { + if (!tracks.Any()) + return false; + + var hasUnmutedTracks = tracks.Any(x => !x.muted); + Mute(tracks.Where(p => !(p is GroupTrack)).ToArray(), hasUnmutedTracks); + return true; + } + + void UpdateMenuName(IEnumerable tracks) + { + menuName = tracks.All(t => t.muted) ? UnmuteSelectedText : MuteSelectedText; + } + + public static void Mute(TrackAsset[] tracks, bool shouldMute) + { + if (tracks.Length == 0) + return; + + foreach (var track in tracks.Where(t => !TimelineUtility.IsParentMuted(t))) + { + TimelineUndo.PushUndo(track, "Mute Tracks"); + track.muted = shouldMute; + } + + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + } + + [MenuEntry("Mute", MenuPriority.TrackActionSection.mute)] + [Shortcut(Shortcuts.Timeline.toggleMute)] + class MuteTrack : TrackAction, IMenuName + { + static readonly string k_MuteText = L10n.Tr("Mute"); + static readonly string k_UnMuteText = L10n.Tr("Unmute"); + + public string menuName { get; private set; } + + void UpdateMenuName(IEnumerable tracks) + { + menuName = tracks.Any(x => !x.muted) ? k_MuteText : k_UnMuteText; + } + + public override bool Execute(IEnumerable tracks) + { + if (!tracks.Any() || tracks.Any(TimelineUtility.IsParentMuted)) + return false; + + var hasUnmutedTracks = tracks.Any(x => !x.muted); + Mute(tracks, hasUnmutedTracks); + return true; + } + + public override ActionValidity Validate(IEnumerable tracks) + { + UpdateMenuName(tracks); + if (tracks.Any(TimelineUtility.IsLockedFromGroup)) + return ActionValidity.Invalid; + return ActionValidity.Valid; + } + + public static void Mute(IEnumerable tracks, bool shouldMute) + { + if (!tracks.Any()) + return; + + foreach (var track in tracks) + { + if (track as GroupTrack == null) + Mute(track.GetChildTracks().ToArray(), shouldMute); + TimelineUndo.PushUndo(track, "Mute Tracks"); + track.muted = shouldMute; + } + + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + } + + class DeleteTracks : TrackAction + { + public static void Do(TimelineAsset timeline, TrackAsset track) + { + SelectionManager.Remove(track); + TrackModifier.DeleteTrack(timeline, track); + } + + public override ActionValidity Validate(IEnumerable tracks) => ActionValidity.Valid; + + public override bool Execute(IEnumerable 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; + } + } + + class CopyTracksToClipboard : TrackAction + { + public static bool Do(TrackAsset[] tracks) + { + var action = new CopyTracksToClipboard(); + return action.Execute(tracks); + } + + public override ActionValidity Validate(IEnumerable tracks) => ActionValidity.Valid; + + public override bool Execute(IEnumerable tracks) + { + TimelineEditor.clipboard.CopyTracks(tracks); + + return true; + } + } + + class DuplicateTracks : TrackAction + { + public override ActionValidity Validate(IEnumerable tracks) => ActionValidity.Valid; + + public override bool Execute(IEnumerable tracks) + { + if (tracks.Any()) + { + SelectionManager.RemoveTimelineSelection(); + } + + foreach (var track in TrackExtensions.FilterTracks(tracks)) + { + var newTrack = track.Duplicate(TimelineEditor.inspectedDirector, TimelineEditor.inspectedDirector); + SelectionManager.Add(newTrack); + foreach (var childTrack in newTrack.GetFlattenedChildTracks()) + { + SelectionManager.Add(childTrack); + } + + if (TimelineEditor.inspectedDirector != null) + { + var binding = TimelineEditor.inspectedDirector.GetGenericBinding(track); + if (binding != null) + { + TimelineUndo.PushUndo(TimelineEditor.inspectedDirector, "Duplicate"); + TimelineEditor.inspectedDirector.SetGenericBinding(newTrack, binding); + } + } + } + + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + + return true; + } + } + + [MenuEntry("Remove Invalid Markers", MenuPriority.TrackActionSection.removeInvalidMarkers), UsedImplicitly] + class RemoveInvalidMarkersAction : TrackAction + { + public override ActionValidity Validate(IEnumerable tracks) + { + if (tracks.Any(target => target != null && target.GetMarkerCount() != target.GetMarkersRaw().Count())) + return ActionValidity.Valid; + + return ActionValidity.NotApplicable; + } + + public override bool Execute(IEnumerable tracks) + { + bool anyRemoved = false; + foreach (var target in tracks) + { + var invalids = target.GetMarkersRaw().Where(x => !(x is IMarker)).ToList(); + foreach (var m in invalids) + { + anyRemoved = true; + target.DeleteMarkerRaw(m); + } + } + + if (anyRemoved) + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + + return anyRemoved; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TrackActions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TrackActions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..483f9ebd634901e063aa572077833eb814ebe140 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Actions/TrackActions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fda82b5ca7a4c5f40b497c4f5f4bd950 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Activation/ActivationTrackEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Activation/ActivationTrackEditor.cs new file mode 100644 index 0000000000000000000000000000000000000000..f4b8ee7e09d1bc4afb7a5c6ec1776a42152c02b5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Activation/ActivationTrackEditor.cs @@ -0,0 +1,56 @@ +using JetBrains.Annotations; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + [UsedImplicitly] + [CustomTimelineEditor(typeof(ActivationTrack))] + class ActivationTrackEditor : TrackEditor + { + static readonly string ClipText = L10n.Tr("Active"); + + static readonly string k_ErrorParentString = L10n.Tr("The bound GameObject is a parent of the PlayableDirector."); + static readonly string k_ErrorString = L10n.Tr("The bound GameObject contains the PlayableDirector."); + + public override TrackDrawOptions GetTrackOptions(TrackAsset track, Object binding) + { + var options = base.GetTrackOptions(track, binding); + options.errorText = GetErrorText(track, binding); + return options; + } + + string GetErrorText(TrackAsset track, Object binding) + { + var gameObject = binding as GameObject; + var currentDirector = TimelineEditor.inspectedDirector; + if (gameObject != null && currentDirector != null) + { + var director = gameObject.GetComponent(); + if (currentDirector == director) + { + return k_ErrorString; + } + + if (currentDirector.gameObject.transform.IsChildOf(gameObject.transform)) + { + return k_ErrorParentString; + } + } + + return base.GetErrorText(track, binding, TrackBindingErrors.PrefabBound); + } + + public override void OnCreate(TrackAsset track, TrackAsset copiedFrom) + { + // Add a default clip to the newly created track + if (copiedFrom == null) + { + var clip = track.CreateClip(0); + clip.displayName = ClipText; + clip.duration = System.Math.Max(clip.duration, track.timelineAsset.duration * 0.5f); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Activation/ActivationTrackEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Activation/ActivationTrackEditor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..64f81a1af6f65da9f2ebd44d2a45d5465fd9af3a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Activation/ActivationTrackEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4fbcc9b1f6ace8c4f8724a88dccca5f8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Activation/ActivationTrackInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Activation/ActivationTrackInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..f391e69011e122e9f81327182590772ff0046417 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Activation/ActivationTrackInspector.cs @@ -0,0 +1,43 @@ +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [CustomEditor(typeof(ActivationTrack))] + class ActivationTrackInspector : TrackAssetInspector + { + static class Styles + { + public static readonly GUIContent PostPlaybackStateText = EditorGUIUtility.TrTextContent("Post-playback state"); + } + + SerializedProperty m_PostPlaybackProperty; + + public override void OnInspectorGUI() + { + using (new EditorGUI.DisabledScope(IsTrackLocked())) + { + serializedObject.Update(); + + EditorGUI.BeginChangeCheck(); + + if (m_PostPlaybackProperty != null) + EditorGUILayout.PropertyField(m_PostPlaybackProperty, Styles.PostPlaybackStateText); + + if (EditorGUI.EndChangeCheck()) + { + serializedObject.ApplyModifiedProperties(); + var activationTrack = target as ActivationTrack; + if (activationTrack != null) + activationTrack.UpdateTrackMode(); + } + } + } + + public override void OnEnable() + { + base.OnEnable(); + m_PostPlaybackProperty = serializedObject.FindProperty("m_PostPlaybackState"); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Activation/ActivationTrackInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Activation/ActivationTrackInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..9c3910c3a77ade90dbcbb108893cc622ab449d0e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Activation/ActivationTrackInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c46b007a3762fc84cb1ee7ca30060f0b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Analytics/TimelineAnalytics.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Analytics/TimelineAnalytics.cs new file mode 100644 index 0000000000000000000000000000000000000000..7e2cc6137d53334f95041ff4f747b91a507fde59 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Analytics/TimelineAnalytics.cs @@ -0,0 +1,170 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.Build; +using UnityEditor.Build.Reporting; +using UnityEngine.Playables; +using UnityEngine.SceneManagement; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Analytics +{ + class TimelineSceneInfo + { + public Dictionary trackCount = new Dictionary + { + {"ActivationTrack", 0}, + {"AnimationTrack", 0}, + {"AudioTrack", 0}, + {"ControlTrack", 0}, + {"PlayableTrack", 0}, + {"UserType", 0}, + {"Other", 0} + }; + + public Dictionary userTrackTypesCount = new Dictionary(); + public HashSet uniqueDirectors = new HashSet(); + public int numTracks = 0; + public int minDuration = int.MaxValue; + public int maxDuration = int.MinValue; + public int minNumTracks = int.MaxValue; + public int maxNumTracks = int.MinValue; + public int numRecorded = 0; + } + + [Serializable] + struct TrackInfo + { + public string name; + public double percent; + } + + [Serializable] + class TimelineEventInfo + { + public int num_timelines; + public int min_duration, max_duration; + public int min_num_tracks, max_num_tracks; + public double recorded_percent; + public List track_info = new List(); + public string most_popular_user_track = string.Empty; + + public TimelineEventInfo(TimelineSceneInfo sceneInfo) + { + num_timelines = sceneInfo.uniqueDirectors.Count; + min_duration = sceneInfo.minDuration; + max_duration = sceneInfo.maxDuration; + min_num_tracks = sceneInfo.minNumTracks; + max_num_tracks = sceneInfo.maxNumTracks; + recorded_percent = Math.Round(100.0 * sceneInfo.numRecorded / sceneInfo.numTracks, 1); + + foreach (KeyValuePair kv in sceneInfo.trackCount.Where(x => x.Value > 0)) + { + track_info.Add(new TrackInfo() + { + name = kv.Key, + percent = Math.Round(100.0 * kv.Value / sceneInfo.numTracks, 1) + }); + } + + if (sceneInfo.userTrackTypesCount.Any()) + { + most_popular_user_track = sceneInfo.userTrackTypesCount + .First(x => x.Value == sceneInfo.userTrackTypesCount.Values.Max()).Key; + } + } + + public static bool IsUserType(Type t) + { + string nameSpace = t.Namespace; + return string.IsNullOrEmpty(nameSpace) || !nameSpace.StartsWith("UnityEngine.Timeline"); + } + } + + + static class TimelineAnalytics + { + static TimelineSceneInfo _timelineSceneInfo = new TimelineSceneInfo(); + + class TimelineAnalyticsPreProcess : IPreprocessBuildWithReport + { + public int callbackOrder { get { return 0; } } + public void OnPreprocessBuild(BuildReport report) + { + _timelineSceneInfo = new TimelineSceneInfo(); + } + } + + class TimelineAnalyticsProcess : IProcessSceneWithReport + { + public int callbackOrder + { + get { return 0; } + } + + public void OnProcessScene(Scene scene, BuildReport report) + { + var timelines = UnityEngine.Object.FindObjectsOfType().Select(pd => pd.playableAsset).OfType().Distinct(); + + foreach (var timeline in timelines) + { + if (_timelineSceneInfo.uniqueDirectors.Add(timeline)) + { + _timelineSceneInfo.numTracks += timeline.flattenedTracks.Count(); + _timelineSceneInfo.minDuration = Math.Min(_timelineSceneInfo.minDuration, (int)(timeline.duration * 1000)); + _timelineSceneInfo.maxDuration = Math.Max(_timelineSceneInfo.maxDuration, (int)(timeline.duration * 1000)); + _timelineSceneInfo.minNumTracks = Math.Min(_timelineSceneInfo.minNumTracks, timeline.flattenedTracks.Count()); + _timelineSceneInfo.maxNumTracks = Math.Max(_timelineSceneInfo.maxNumTracks, timeline.flattenedTracks.Count()); + + foreach (var track in timeline.flattenedTracks) + { + string key = track.GetType().Name; + if (_timelineSceneInfo.trackCount.ContainsKey(key)) + { + _timelineSceneInfo.trackCount[key]++; + } + else + { + if (TimelineEventInfo.IsUserType(track.GetType())) + { + _timelineSceneInfo.trackCount["UserType"]++; + if (_timelineSceneInfo.userTrackTypesCount.ContainsKey(key)) + _timelineSceneInfo.userTrackTypesCount[key]++; + else + _timelineSceneInfo.userTrackTypesCount[key] = 1; + } + else + _timelineSceneInfo.trackCount["Other"]++; + } + + if (track.clips.Any(x => x.recordable)) + _timelineSceneInfo.numRecorded++; + else + { + var animationTrack = track as AnimationTrack; + if (animationTrack != null) + { + if (animationTrack.CanConvertToClipMode()) + _timelineSceneInfo.numRecorded++; + } + } + } + } + } + } + } + + class TimelineAnalyticsPostProcess : IPostprocessBuildWithReport + { + public int callbackOrder {get { return 0; }} + public void OnPostprocessBuild(BuildReport report) + { + if (_timelineSceneInfo.uniqueDirectors.Count > 0) + { + var timelineEvent = new TimelineEventInfo(_timelineSceneInfo); + EditorAnalytics.SendEventTimelineInfo(timelineEvent); + } + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Analytics/TimelineAnalytics.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Analytics/TimelineAnalytics.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e296bda0ad6f0d4028330ec0fbb51a4413e994be --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Analytics/TimelineAnalytics.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 10ba9bc9317e315439b0223674162c52 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipActions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipActions.cs new file mode 100644 index 0000000000000000000000000000000000000000..46b7cd5e71fe8981d2dd9183290e435f4813c70a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipActions.cs @@ -0,0 +1,101 @@ +using System.Collections.Generic; +using System.Linq; +using JetBrains.Annotations; +using UnityEditor.Timeline.Actions; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + [ApplyDefaultUndo("Match Offsets")] + [MenuEntry("Match Offsets To Previous Clip", MenuPriority.CustomClipActionSection.matchPrevious), UsedImplicitly] + class MatchOffsetsPreviousAction : ClipAction + { + public override bool Execute(IEnumerable clips) + { + if (clips == null || !clips.Any()) + return false; + AnimationOffsetMenu.MatchClipsToPrevious(clips.Where(x => IsValidClip(x, TimelineEditor.inspectedDirector)).ToArray()); + return true; + } + + static bool IsValidClip(TimelineClip clip, PlayableDirector director) + { + return clip != null && + clip.parentTrack != null && + (clip.asset as AnimationPlayableAsset) != null && + clip.parentTrack.clips.Any(x => x.start < clip.start) && + TimelineUtility.GetSceneGameObject(director, clip.parentTrack) != null; + } + + public override ActionValidity Validate(IEnumerable clips) + { + if (!clips.All(TimelineAnimationUtilities.IsAnimationClip)) + return ActionValidity.NotApplicable; + + var director = TimelineEditor.inspectedDirector; + if (TimelineEditor.inspectedDirector == null) + return ActionValidity.NotApplicable; + + if (clips.Any(c => IsValidClip(c, director))) + return ActionValidity.Valid; + + return ActionValidity.NotApplicable; + } + } + + [ApplyDefaultUndo("Match Offsets")] + [MenuEntry("Match Offsets To Next Clip", MenuPriority.CustomClipActionSection.matchNext), UsedImplicitly] + class MatchOffsetsNextAction : ClipAction + { + public override bool Execute(IEnumerable clips) + { + AnimationOffsetMenu.MatchClipsToNext(clips.Where(x => IsValidClip(x, TimelineEditor.inspectedDirector)).ToArray()); + return true; + } + + static bool IsValidClip(TimelineClip clip, PlayableDirector director) + { + return clip != null && + clip.parentTrack != null && + (clip.asset as AnimationPlayableAsset) != null && + clip.parentTrack.clips.Any(x => x.start > clip.start) && + TimelineUtility.GetSceneGameObject(director, clip.parentTrack) != null; + } + + public override ActionValidity Validate(IEnumerable clips) + { + if (!clips.All(TimelineAnimationUtilities.IsAnimationClip)) + return ActionValidity.NotApplicable; + + var director = TimelineEditor.inspectedDirector; + if (TimelineEditor.inspectedDirector == null) + return ActionValidity.NotApplicable; + + if (clips.Any(c => IsValidClip(c, director))) + return ActionValidity.Valid; + + return ActionValidity.NotApplicable; + } + } + + [ApplyDefaultUndo] + [MenuEntry("Reset Offsets", MenuPriority.CustomClipActionSection.resetOffset), UsedImplicitly] + class ResetOffsets : ClipAction + { + public override bool Execute(IEnumerable clips) + { + AnimationOffsetMenu.ResetClipOffsets(clips.Where(TimelineAnimationUtilities.IsAnimationClip).ToArray()); + return true; + } + + public override ActionValidity Validate(IEnumerable clips) + { + if (!clips.All(TimelineAnimationUtilities.IsAnimationClip)) + return ActionValidity.NotApplicable; + + return ActionValidity.Valid; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipActions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipActions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..0632984fcb1ede8a8e67c09a9ee1c827141546a1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipActions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bf22284ca28e7ef4490033b61e9b52cd +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipCurveCache.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipCurveCache.cs new file mode 100644 index 0000000000000000000000000000000000000000..c726611500e334746337d6d9f8268301fd043fc4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipCurveCache.cs @@ -0,0 +1,427 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEditor; +using UnityEditorInternal; + +namespace UnityEditor.Timeline +{ + struct CurveBindingPair + { + public EditorCurveBinding binding; + public AnimationCurve curve; + public ObjectReferenceKeyframe[] objectCurve; + } + + class CurveBindingGroup + { + public CurveBindingPair[] curveBindingPairs { get; set; } + public Vector2 timeRange { get; set; } + public Vector2 valueRange { get; set; } + + public bool isFloatCurve + { + get + { + return curveBindingPairs != null && curveBindingPairs.Length > 0 && + curveBindingPairs[0].curve != null; + } + } + + public bool isObjectCurve + { + get + { + return curveBindingPairs != null && curveBindingPairs.Length > 0 && + curveBindingPairs[0].objectCurve != null; + } + } + + public int count + { + get + { + if (curveBindingPairs == null) + return 0; + return curveBindingPairs.Length; + } + } + } + + class AnimationClipCurveInfo + { + bool m_CurveDirty = true; + bool m_KeysDirty = true; + + public bool dirty + { + get { return m_CurveDirty; } + set + { + m_CurveDirty = value; + if (m_CurveDirty) + { + m_KeysDirty = true; + if (m_groupings != null) + m_groupings.Clear(); + } + } + } + + public AnimationCurve[] curves; + public EditorCurveBinding[] bindings; + + public EditorCurveBinding[] objectBindings; + public List objectCurves; + + Dictionary m_groupings; + + // to tell whether the cache has changed + public int version { get; private set; } + + float[] m_KeyTimes; + + Dictionary m_individualBindinsKey; + + public float[] keyTimes + { + get + { + if (m_KeysDirty || m_KeyTimes == null) + { + RebuildKeyCache(); + } + return m_KeyTimes; + } + } + + public float[] GetCurveTimes(EditorCurveBinding curve) + { + return GetCurveTimes(new[] { curve }); + } + + public float[] GetCurveTimes(EditorCurveBinding[] curves) + { + if (m_KeysDirty || m_KeyTimes == null) + { + RebuildKeyCache(); + } + + var keyTimes = new List(); + for (int i = 0; i < curves.Length; i++) + { + var c = curves[i]; + if (m_individualBindinsKey.ContainsKey(c)) + { + keyTimes.AddRange(m_individualBindinsKey[c]); + } + } + return keyTimes.ToArray(); + } + + void RebuildKeyCache() + { + m_individualBindinsKey = new Dictionary(); + + List keys = curves.SelectMany(y => y.keys).Select(z => z.time).ToList(); + for (int i = 0; i < objectCurves.Count; i++) + { + var kf = objectCurves[i]; + keys.AddRange(kf.Select(x => x.time)); + } + + for (int b = 0; b < bindings.Count(); b++) + { + m_individualBindinsKey.Add(bindings[b], curves[b].keys.Select(k => k.time).Distinct().ToArray()); + } + + m_KeyTimes = keys.OrderBy(x => x).Distinct().ToArray(); + m_KeysDirty = false; + } + + public void Update(AnimationClip clip) + { + List postfilter = new List(); + var clipBindings = AnimationUtility.GetCurveBindings(clip); + for (int i = 0; i < clipBindings.Length; i++) + { + var bind = clipBindings[i]; + if (!bind.propertyName.Contains("LocalRotation.w")) + postfilter.Add(RotationCurveInterpolation.RemapAnimationBindingForRotationCurves(bind, clip)); + } + bindings = postfilter.ToArray(); + + curves = new AnimationCurve[bindings.Length]; + for (int i = 0; i < bindings.Length; i++) + { + curves[i] = AnimationUtility.GetEditorCurve(clip, bindings[i]); + } + + objectBindings = AnimationUtility.GetObjectReferenceCurveBindings(clip); + objectCurves = new List(objectBindings.Length); + for (int i = 0; i < objectBindings.Length; i++) + { + objectCurves.Add(AnimationUtility.GetObjectReferenceCurve(clip, objectBindings[i])); + } + + m_CurveDirty = false; + m_KeysDirty = true; + + version = version + 1; + } + + public bool GetBindingForCurve(AnimationCurve curve, ref EditorCurveBinding binding) + { + for (int i = 0; i < curves.Length; i++) + { + if (curve == curves[i]) + { + binding = bindings[i]; + return true; + } + } + return false; + } + + public AnimationCurve GetCurveForBinding(EditorCurveBinding binding) + { + for (int i = 0; i < curves.Length; i++) + { + if (binding.Equals(bindings[i])) + { + return curves[i]; + } + } + return null; + } + + public ObjectReferenceKeyframe[] GetObjectCurveForBinding(EditorCurveBinding binding) + { + if (objectCurves == null) + return null; + + for (int i = 0; i < objectCurves.Count; i++) + { + if (binding.Equals(objectBindings[i])) + { + return objectCurves[i]; + } + } + return null; + } + + // given a groupID, get the list of curve bindings + public CurveBindingGroup GetGroupBinding(string groupID) + { + if (m_groupings == null) + m_groupings = new Dictionary(); + + CurveBindingGroup result = null; + if (!m_groupings.TryGetValue(groupID, out result)) + { + result = new CurveBindingGroup(); + result.timeRange = new Vector2(float.MaxValue, float.MinValue); + result.valueRange = new Vector2(float.MaxValue, float.MinValue); + List found = new List(); + for (int i = 0; i < bindings.Length; i++) + { + if (bindings[i].GetGroupID() == groupID) + { + CurveBindingPair pair = new CurveBindingPair(); + pair.binding = bindings[i]; + pair.curve = curves[i]; + found.Add(pair); + + for (int k = 0; k < curves[i].keys.Length; k++) + { + var key = curves[i].keys[k]; + result.timeRange = new Vector2(Mathf.Min(key.time, result.timeRange.x), Mathf.Max(key.time, result.timeRange.y)); + result.valueRange = new Vector2(Mathf.Min(key.value, result.valueRange.x), Mathf.Max(key.value, result.valueRange.y)); + } + } + } + for (int i = 0; i < objectBindings.Length; i++) + { + if (objectBindings[i].GetGroupID() == groupID) + { + CurveBindingPair pair = new CurveBindingPair(); + pair.binding = objectBindings[i]; + pair.objectCurve = objectCurves[i]; + found.Add(pair); + + for (int k = 0; k < objectCurves[i].Length; k++) + { + var key = objectCurves[i][k]; + result.timeRange = new Vector2(Mathf.Min(key.time, result.timeRange.x), Mathf.Max(key.time, result.timeRange.y)); + } + } + } + + result.curveBindingPairs = found.OrderBy(x => AnimationWindowUtility.GetComponentIndex(x.binding.propertyName)).ToArray(); + + m_groupings.Add(groupID, result); + } + return result; + } + } + + // Cache for storing the animation clip data + class AnimationClipCurveCache + { + static AnimationClipCurveCache s_Instance; + Dictionary m_ClipCache = new Dictionary(); + bool m_IsEnabled; + + + public static AnimationClipCurveCache Instance + { + get + { + if (s_Instance == null) + { + s_Instance = new AnimationClipCurveCache(); + } + + return s_Instance; + } + } + + public void OnEnable() + { + if (!m_IsEnabled) + { + AnimationUtility.onCurveWasModified += OnCurveWasModified; + m_IsEnabled = true; + } + } + + public void OnDisable() + { + if (m_IsEnabled) + { + AnimationUtility.onCurveWasModified -= OnCurveWasModified; + m_IsEnabled = false; + } + } + + // callback when a curve is edited. Force the cache to update next time it's accessed + void OnCurveWasModified(AnimationClip clip, EditorCurveBinding binding, AnimationUtility.CurveModifiedType modification) + { + AnimationClipCurveInfo data; + if (m_ClipCache.TryGetValue(clip, out data)) + { + data.dirty = true; + } + } + + public AnimationClipCurveInfo GetCurveInfo(AnimationClip clip) + { + AnimationClipCurveInfo data; + if (clip == null) + return null; + if (!m_ClipCache.TryGetValue(clip, out data)) + { + data = new AnimationClipCurveInfo(); + data.dirty = true; + m_ClipCache[clip] = data; + } + if (data.dirty) + { + data.Update(clip); + } + return data; + } + + public void ClearCachedProxyClips() + { + var toRemove = new List(); + foreach (var entry in m_ClipCache) + { + var clip = entry.Key; + if (clip != null && (clip.hideFlags & HideFlags.HideAndDontSave) == HideFlags.HideAndDontSave) + toRemove.Add(clip); + } + + foreach (var clip in toRemove) + { + m_ClipCache.Remove(clip); + Object.DestroyImmediate(clip, true); + } + } + + public void Clear() + { + ClearCachedProxyClips(); + m_ClipCache.Clear(); + } + } + + static class EditorCurveBindingExtension + { + // identifier to generate an id thats the same for all curves in the same group + public static string GetGroupID(this EditorCurveBinding binding) + { + return binding.type + AnimationWindowUtility.GetPropertyGroupName(binding.propertyName); + } + } + + + static class CurveBindingGroupExtensions + { + // Extentions to determine curve types + public static bool IsEnableGroup(this CurveBindingGroup curves) + { + return curves.isFloatCurve && curves.count == 1 && curves.curveBindingPairs[0].binding.propertyName == "m_Enabled"; + } + + public static bool IsVectorGroup(this CurveBindingGroup curves) + { + if (!curves.isFloatCurve) + return false; + if (curves.count <= 1 || curves.count > 4) + return false; + char l = curves.curveBindingPairs[0].binding.propertyName.Last(); + return l == 'x' || l == 'y' || l == 'z' || l == 'w'; + } + + public static bool IsColorGroup(this CurveBindingGroup curves) + { + if (!curves.isFloatCurve) + return false; + if (curves.count != 3 && curves.count != 4) + return false; + char l = curves.curveBindingPairs[0].binding.propertyName.Last(); + return l == 'r' || l == 'g' || l == 'b' || l == 'a'; + } + + public static string GetDescription(this CurveBindingGroup group, float t) + { + string result = string.Empty; + if (group.isFloatCurve) + { + if (group.count > 1) + { + result += "(" + group.curveBindingPairs[0].curve.Evaluate(t).ToString("0.##"); + for (int j = 1; j < group.curveBindingPairs.Length; j++) + { + result += "," + group.curveBindingPairs[j].curve.Evaluate(t).ToString("0.##"); + } + result += ")"; + } + else + { + result = group.curveBindingPairs[0].curve.Evaluate(t).ToString("0.##"); + } + } + else if (group.isObjectCurve) + { + Object obj = null; + if (group.curveBindingPairs[0].objectCurve.Length > 0) + obj = CurveEditUtility.Evaluate(group.curveBindingPairs[0].objectCurve, t); + result = (obj == null ? "None" : obj.name); + } + + return result; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipCurveCache.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipCurveCache.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..47fcaa3f97412f94fb01df1ad6664f6554dc1dde --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipCurveCache.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 07a967d2fca95324f8922df8394a5655 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipExtensions.cs new file mode 100644 index 0000000000000000000000000000000000000000..08343c08b8eb4baf6c386a7fb029fa716865dded --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipExtensions.cs @@ -0,0 +1,34 @@ +using System; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + static class AnimationClipExtensions + { + public static UInt64 ClipVersion(this AnimationClip clip) + { + if (clip == null) + return 0; + + var info = AnimationClipCurveCache.Instance.GetCurveInfo(clip); + var version = (UInt32) info.version; + var count = (UInt32) info.curves.Length; + var result = (UInt64) version; + result |= ((UInt64) count) << 32; + return result; + } + + public static CurveChangeType GetChangeType(this AnimationClip clip, ref UInt64 curveVersion) + { + var version = clip.ClipVersion(); + var changeType = CurveChangeType.None; + if ((curveVersion >> 32) != (version >> 32)) + changeType = CurveChangeType.CurveAddedOrRemoved; + else if (curveVersion != version) + changeType = CurveChangeType.CurveModified; + + curveVersion = version; + return changeType; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipExtensions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..80b13868a36676da1288ca5deee08fd4b1f49e7b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationClipExtensions.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: c3b87750f9f94e8c918b71ec7d369bd4 +timeCreated: 1602859563 \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationOffsetMenu.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationOffsetMenu.cs new file mode 100644 index 0000000000000000000000000000000000000000..32cc9780386bcd6be5fda79806182199a73f87af --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationOffsetMenu.cs @@ -0,0 +1,73 @@ +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class AnimationOffsetMenu + { + public static string MatchFieldsPrefix = "Match Offsets Fields/"; + + static bool EnforcePreviewMode() + { + TimelineEditor.state.previewMode = true; // try and set the preview mode + if (!TimelineEditor.state.previewMode) + { + Debug.LogError("Match clips cannot be completed because preview mode cannot be enabed"); + return false; + } + return true; + } + + internal static void MatchClipsToPrevious(TimelineClip[] clips) + { + if (!EnforcePreviewMode()) + return; + + clips = clips.OrderBy(x => x.start).ToArray(); + foreach (var clip in clips) + { + var sceneObject = TimelineUtility.GetSceneGameObject(TimelineEditor.inspectedDirector, clip.parentTrack); + if (sceneObject != null) + { + TimelineAnimationUtilities.MatchPrevious(clip, sceneObject.transform, TimelineEditor.inspectedDirector); + } + } + + InspectorWindow.RepaintAllInspectors(); + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + 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.parentTrack); + if (sceneObject != null) + { + TimelineAnimationUtilities.MatchNext(clip, sceneObject.transform, TimelineEditor.inspectedDirector); + } + } + + InspectorWindow.RepaintAllInspectors(); + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + public static void ResetClipOffsets(TimelineClip[] clips) + { + foreach (var clip in clips) + { + var asset = clip.asset as AnimationPlayableAsset; + if (asset != null) + asset.ResetOffsets(); + } + + InspectorWindow.RepaintAllInspectors(); + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationOffsetMenu.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationOffsetMenu.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e628663bca09d5e3c728646e1b08955a717b1d17 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationOffsetMenu.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9ace5095cc37ed849b52109d2ee305d4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationPlayableAssetEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationPlayableAssetEditor.cs new file mode 100644 index 0000000000000000000000000000000000000000..815bfb5f3992491e8a97007bf5c155dc561e4537 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationPlayableAssetEditor.cs @@ -0,0 +1,65 @@ +using JetBrains.Annotations; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [CustomTimelineEditor(typeof(AnimationPlayableAsset)), UsedImplicitly] + class AnimationPlayableAssetEditor : ClipEditor + { + public static readonly string k_NoClipAssignedError = L10n.Tr("No animation clip assigned"); + public static readonly string k_LegacyClipError = L10n.Tr("Legacy animation clips are not supported"); + static readonly string k_MotionCurveError = L10n.Tr("You are using motion curves without applyRootMotion enabled on the Animator. The root transform will not be animated"); + static readonly string k_RootCurveError = L10n.Tr("You are using root curves without applyRootMotion enabled on the Animator. The root transform will not be animated"); + + /// + public override ClipDrawOptions GetClipOptions(TimelineClip clip) + { + var clipOptions = base.GetClipOptions(clip); + var asset = clip.asset as AnimationPlayableAsset; + + if (asset != null) + clipOptions.errorText = GetErrorText(asset, clip.parentTrack as AnimationTrack, clipOptions.errorText); + + if (clip.recordable) + clipOptions.highlightColor = DirectorStyles.Instance.customSkin.colorAnimationRecorded; + + return clipOptions; + } + + /// + public override void OnCreate(TimelineClip clip, TrackAsset track, TimelineClip clonedFrom) + { + var asset = clip.asset as AnimationPlayableAsset; + if (asset != null && asset.clip != null && asset.clip.legacy) + { + asset.clip = null; + Debug.LogError("Legacy Animation Clips are not supported"); + } + } + + string GetErrorText(AnimationPlayableAsset animationAsset, AnimationTrack track, string defaultError) + { + if (animationAsset.clip == null) + return k_NoClipAssignedError; + if (animationAsset.clip.legacy) + return k_LegacyClipError; + if (animationAsset.clip.hasMotionCurves || animationAsset.clip.hasRootCurves) + { + if (track != null && track.trackOffset == TrackOffset.Auto) + { + var animator = track.GetBinding(TimelineEditor.inspectedDirector); + if (animator != null && !animator.applyRootMotion && !animationAsset.clip.hasGenericRootTransform) + { + if (animationAsset.clip.hasMotionCurves) + return k_MotionCurveError; + return k_RootCurveError; + } + } + } + + return defaultError; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationPlayableAssetEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationPlayableAssetEditor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..0a749e88710bd1c992fdcc681b070e958ba7ef93 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationPlayableAssetEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f7fed0d9d0f7a7f41a8525aa79e790b1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationTrackActions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationTrackActions.cs new file mode 100644 index 0000000000000000000000000000000000000000..7049a8306402b0135a3f40daef6ee2ae1ca077cb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationTrackActions.cs @@ -0,0 +1,151 @@ +using System.Collections.Generic; +using System.Linq; +using JetBrains.Annotations; +using UnityEditor.Timeline.Actions; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [MenuEntry("Add Override Track", MenuPriority.CustomTrackActionSection.addOverrideTrack), UsedImplicitly] + class AddOverrideTrackAction : TrackAction + { + public override bool Execute(IEnumerable tracks) + { + foreach (var animTrack in tracks.OfType()) + { + TimelineHelpers.CreateTrack(typeof(AnimationTrack), animTrack, "Override " + animTrack.GetChildTracks().Count()); + } + + return true; + } + + public override ActionValidity Validate(IEnumerable tracks) + { + if (tracks.Any(t => t.isSubTrack || !t.GetType().IsAssignableFrom(typeof(AnimationTrack)))) + return ActionValidity.NotApplicable; + + if (tracks.Any(t => t.lockedInHierarchy)) + return ActionValidity.Invalid; + + return ActionValidity.Valid; + } + } + + [MenuEntry("Convert To Clip Track", MenuPriority.CustomTrackActionSection.convertToClipMode), UsedImplicitly] + class ConvertToClipModeAction : TrackAction + { + public override bool Execute(IEnumerable tracks) + { + foreach (var animTrack in tracks.OfType()) + animTrack.ConvertToClipMode(); + + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + + return true; + } + + public override ActionValidity Validate(IEnumerable tracks) + { + if (tracks.Any(t => !t.GetType().IsAssignableFrom(typeof(AnimationTrack)))) + return ActionValidity.NotApplicable; + + if (tracks.Any(t => t.lockedInHierarchy)) + return ActionValidity.Invalid; + + if (tracks.OfType().All(a => a.CanConvertToClipMode())) + return ActionValidity.Valid; + + return ActionValidity.NotApplicable; + } + } + + [MenuEntry("Convert To Infinite Clip", MenuPriority.CustomTrackActionSection.convertFromClipMode), UsedImplicitly] + class ConvertFromClipTrackAction : TrackAction + { + public override bool Execute(IEnumerable tracks) + { + foreach (var animTrack in tracks.OfType()) + animTrack.ConvertFromClipMode(TimelineEditor.inspectedAsset); + + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + + return true; + } + + public override ActionValidity Validate(IEnumerable tracks) + { + if (tracks.Any(t => !t.GetType().IsAssignableFrom(typeof(AnimationTrack)))) + return ActionValidity.NotApplicable; + + if (tracks.Any(t => t.lockedInHierarchy)) + return ActionValidity.Invalid; + + if (tracks.OfType().All(a => a.CanConvertFromClipMode())) + return ActionValidity.Valid; + + return ActionValidity.NotApplicable; + } + } + + abstract class TrackOffsetBaseAction : TrackAction + { + public abstract TrackOffset trackOffset { get; } + + public override ActionValidity Validate(IEnumerable tracks) + { + if (tracks.Any(t => !t.GetType().IsAssignableFrom(typeof(AnimationTrack)))) + return ActionValidity.NotApplicable; + + if (tracks.Any(t => t.lockedInHierarchy)) + { + return ActionValidity.Invalid; + } + + return ActionValidity.Valid; + } + + public override bool Execute(IEnumerable tracks) + { + foreach (var animTrack in tracks.OfType()) + { + animTrack.UnarmForRecord(); + animTrack.trackOffset = trackOffset; + } + + TimelineEditor.Refresh(RefreshReason.ContentsModified); + return true; + } + } + + + [MenuEntry("Track Offsets/Apply Transform Offsets", MenuPriority.CustomTrackActionSection.applyTrackOffset), UsedImplicitly] + [ApplyDefaultUndo] + class ApplyTransformOffsetAction : TrackOffsetBaseAction + { + public override TrackOffset trackOffset + { + get { return TrackOffset.ApplyTransformOffsets; } + } + } + + [MenuEntry("Track Offsets/Apply Scene Offsets", MenuPriority.CustomTrackActionSection.applySceneOffset), UsedImplicitly] + [ApplyDefaultUndo] + class ApplySceneOffsetAction : TrackOffsetBaseAction + { + public override TrackOffset trackOffset + { + get { return TrackOffset.ApplySceneOffsets; } + } + } + + [MenuEntry("Track Offsets/Auto (Deprecated)", MenuPriority.CustomTrackActionSection.applyAutoOffset), UsedImplicitly] + [ApplyDefaultUndo] + class ApplyAutoAction : TrackOffsetBaseAction + { + public override TrackOffset trackOffset + { + get { return TrackOffset.Auto; } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationTrackActions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationTrackActions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..4ca0e4dca96840a36f579e74bb80081b63ea04f7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/AnimationTrackActions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d4553f2006f48b6448553cb525d2876e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingSelector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingSelector.cs new file mode 100644 index 0000000000000000000000000000000000000000..d4596a8d21ad27ad085e94c47f69ec54c82d5e8c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingSelector.cs @@ -0,0 +1,179 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.IMGUI.Controls; +using UnityEditorInternal; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class BindingSelector + { + TreeViewController m_TreeView; + public TreeViewController treeViewController + { + get { return m_TreeView; } + } + + TreeViewState m_TrackGlobalTreeViewState; + TreeViewState m_TreeViewState; + BindingTreeViewDataSource m_TreeViewDataSource; + CurveDataSource m_CurveDataSource; + TimelineWindow m_Window; + CurveEditor m_CurveEditor; + ReorderableList m_DopeLines; + + string[] m_StringList = {}; + int[] m_Selection; + bool m_PartOfSelection; + public BindingSelector(EditorWindow window, CurveEditor curveEditor, TreeViewState trackGlobalTreeViewState) + { + m_Window = window as TimelineWindow; + m_CurveEditor = curveEditor; + m_TrackGlobalTreeViewState = trackGlobalTreeViewState; + + m_DopeLines = new ReorderableList(m_StringList, typeof(string), false, false, false, false); + m_DopeLines.drawElementBackgroundCallback = null; + m_DopeLines.showDefaultBackground = false; + m_DopeLines.index = 0; + m_DopeLines.headerHeight = 0; + m_DopeLines.elementHeight = 20; + m_DopeLines.draggable = false; + } + + public void OnGUI(Rect targetRect) + { + if (m_TreeView == null) + return; + + m_TreeView.OnEvent(); + m_TreeView.OnGUI(targetRect, GUIUtility.GetControlID(FocusType.Passive)); + } + + public void InitIfNeeded(Rect rect, CurveDataSource dataSource, bool isNewSelection) + { + if (Event.current.type != EventType.Layout) + return; + + m_CurveDataSource = dataSource; + var clip = dataSource.animationClip; + + List allBindings = new List(); + allBindings.Add(new EditorCurveBinding { propertyName = "Summary" }); + if (clip != null) + allBindings.AddRange(AnimationUtility.GetCurveBindings(clip)); + + m_DopeLines.list = allBindings.ToArray(); + + if (m_TreeViewState != null) + { + if (isNewSelection) + RefreshAll(); + + return; + } + + m_TreeViewState = m_TrackGlobalTreeViewState != null ? m_TrackGlobalTreeViewState : new TreeViewState(); + + m_TreeView = new TreeViewController(m_Window, m_TreeViewState) + { + useExpansionAnimation = false, + deselectOnUnhandledMouseDown = true + }; + + m_TreeView.selectionChangedCallback += OnItemSelectionChanged; + + m_TreeViewDataSource = new BindingTreeViewDataSource(m_TreeView, clip, m_CurveDataSource); + + m_TreeView.Init(rect, m_TreeViewDataSource, new BindingTreeViewGUI(m_TreeView), null); + + m_TreeViewDataSource.UpdateData(); + + RefreshSelection(); + } + + void OnItemSelectionChanged(int[] selection) + { + RefreshSelection(selection); + } + + void RefreshAll() + { + RefreshTree(); + RefreshSelection(); + } + + void RefreshSelection() + { + RefreshSelection(m_TreeViewState.selectedIDs != null ? m_TreeViewState.selectedIDs.ToArray() : null); + } + + void RefreshSelection(int[] selection) + { + if (selection == null || selection.Length == 0) + { + // select all. + if (m_TreeViewDataSource.GetRows().Count > 0) + { + m_Selection = m_TreeViewDataSource.GetRows().Select(r => r.id).ToArray(); + } + } + else + { + m_Selection = selection; + } + + RefreshCurves(); + } + + public void RefreshCurves() + { + if (m_CurveDataSource == null || m_Selection == null) + return; + + var bindings = new HashSet(AnimationPreviewUtilities.EditorCurveBindingComparer.Instance); + foreach (int s in m_Selection) + { + var item = (CurveTreeViewNode)m_TreeView.FindItem(s); + if (item != null && item.bindings != null) + bindings.UnionWith(item.bindings); + } + var wrappers = m_CurveDataSource.GenerateWrappers(bindings); + m_CurveEditor.animationCurves = wrappers.ToArray(); + } + + public void RefreshTree() + { + if (m_TreeViewDataSource == null) + return; + + if (m_Selection == null) + m_Selection = new int[0]; + + // get the names of the previous items + var selected = m_Selection.Select(x => m_TreeViewDataSource.FindItem(x)).Where(t => t != null).Select(c => c.displayName).ToArray(); + + // update the source + m_TreeViewDataSource.UpdateData(); + + // find the same items + var reselected = m_TreeViewDataSource.GetRows().Where(x => selected.Contains(x.displayName)).Select(x => x.id).ToArray(); + if (!reselected.Any()) + { + if (m_TreeViewDataSource.GetRows().Count > 0) + { + reselected = new[] { m_TreeViewDataSource.GetItem(0).id }; + } + } + + // update the selection + OnItemSelectionChanged(reselected); + } + + internal virtual bool IsRenamingNodeAllowed(TreeViewItem node) + { + return false; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingSelector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingSelector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..b08aa56aada848e25956ca2a951c3b4cb0fb0bba --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingSelector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c171b9ca03610ea4faa426e082a1075d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingTreeViewDataSource.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingTreeViewDataSource.cs new file mode 100644 index 0000000000000000000000000000000000000000..bb7971f261c1e4ba920abf98cc200b011ddcca82 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingTreeViewDataSource.cs @@ -0,0 +1,219 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor; +using UnityEditor.IMGUI.Controls; +using UnityEditorInternal; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class BindingTreeViewDataSource : TreeViewDataSource + { + struct BindingGroup : IEquatable, IComparable + { + public readonly string GroupName; + public readonly string Path; + public readonly Type Type; + + public BindingGroup(string path, string groupName, Type type) + { + Path = path; + GroupName = groupName; + Type = type; + } + public string groupDisplayName => string.IsNullOrEmpty(Path) ? GroupName : string.Format($"{Path} : {GroupName}"); + public bool Equals(BindingGroup other) => GroupName == other.GroupName && Type == other.Type && Path == other.Path; + public int CompareTo(BindingGroup other) => GetHashCode() - other.GetHashCode(); + public override bool Equals(object obj)=> obj is BindingGroup other && Equals(other); + public override int GetHashCode() + { + return HashUtility.CombineHash(GroupName != null ? GroupName.GetHashCode() : 0, Type != null ? Type.GetHashCode() : 0, Path != null ? Path.GetHashCode() : 0); + } + } + + static readonly string s_DefaultValue = L10n.Tr("{0} (Default Value)"); + + public const int RootID = int.MinValue; + public const int GroupID = -1; + + private readonly AnimationClip m_Clip; + private readonly CurveDataSource m_CurveDataSource; + + public BindingTreeViewDataSource( + TreeViewController treeView, AnimationClip clip, CurveDataSource curveDataSource) + : base(treeView) + { + m_Clip = clip; + showRootItem = false; + m_CurveDataSource = curveDataSource; + } + + void SetupRootNodeSettings() + { + showRootItem = false; + SetExpanded(RootID, true); + SetExpanded(GroupID, true); + } + + public override void FetchData() + { + if (m_Clip == null) + return; + + var bindings = AnimationUtility.GetCurveBindings(m_Clip) + .Union(AnimationUtility.GetObjectReferenceCurveBindings(m_Clip)) + .ToArray(); + + // a sorted linear list of nodes + var results = bindings.GroupBy(GetBindingGroup, p => p, CreateTuple) + .OrderBy(t => t.Item1.Path) + .ThenBy(NamePrioritySort) + // this makes component ordering match the animation window + .ThenBy(t => t.Item1.Type.ToString()) + .ThenBy(t => t.Item1.GroupName).ToArray(); + + m_RootItem = new CurveTreeViewNode(RootID, null, "root", null) + { + children = new List(1) + }; + + if (results.Any()) + { + var groupingNode = new CurveTreeViewNode(GroupID, m_RootItem, m_CurveDataSource.groupingName, bindings) + { + children = new List() + }; + + m_RootItem.children.Add(groupingNode); + + foreach (var r in results) + { + var key = r.Item1; + var nodeBindings = r.Item2; + + FillMissingTransformCurves(nodeBindings); + if (nodeBindings.Count == 1) + groupingNode.children.Add(CreateLeafNode(nodeBindings[0], groupingNode, PropertyName(nodeBindings[0], true))); + else if (nodeBindings.Count > 1) + { + var childBindings = nodeBindings.OrderBy(BindingSort).ToArray(); + var parent = new CurveTreeViewNode(key.GetHashCode(), groupingNode, key.groupDisplayName, childBindings) {children = new List()}; + groupingNode.children.Add(parent); + foreach (var b in childBindings) + parent.children.Add(CreateLeafNode(b, parent, PropertyName(b, false))); + } + } + SetupRootNodeSettings(); + } + + m_NeedRefreshRows = true; + } + + + public void UpdateData() + { + m_TreeView.ReloadData(); + } + + string GroupName(EditorCurveBinding binding) + { + var propertyName = m_CurveDataSource.ModifyPropertyDisplayName(binding.path, binding.propertyName); + return CleanUpArrayBinding(AnimationWindowUtility.NicifyPropertyGroupName(binding.type, propertyName), true); + } + + static string CleanUpArrayBinding(string propertyName, bool isGroup) + { + const string arrayIndicator = ".Array.data["; + const string arrayDisplay = ".data["; + + var arrayIndex = propertyName.LastIndexOf(arrayIndicator, StringComparison.Ordinal); + if (arrayIndex == -1) + return propertyName; + if (isGroup) + propertyName = propertyName.Substring(0, arrayIndex); + return propertyName.Replace(arrayIndicator, arrayDisplay ); + } + + string PropertyName(EditorCurveBinding binding, bool prependPathName) + { + var propertyName = m_CurveDataSource.ModifyPropertyDisplayName(binding.path, binding.propertyName); + propertyName = CleanUpArrayBinding(AnimationWindowUtility.GetPropertyDisplayName(propertyName), false); + if (binding.isPhantom) + propertyName = string.Format(s_DefaultValue, propertyName); + if (prependPathName && !string.IsNullOrEmpty(binding.path)) + propertyName = $"{binding.path} : {propertyName}"; + return propertyName; + } + + BindingGroup GetBindingGroup(EditorCurveBinding binding) + { + return new BindingGroup(binding.path ?? string.Empty, GroupName(binding), binding.type); + } + + static CurveTreeViewNode CreateLeafNode(EditorCurveBinding binding, TreeViewItem parent, string displayName) + { + return new CurveTreeViewNode(binding.GetHashCode(), parent, displayName, new[] { binding }, AnimationWindowUtility.ForceGrouping(binding)); + } + + static void FillMissingTransformCurves(List bindings) + { + if (!AnimationWindowUtility.IsActualTransformCurve(bindings[0]) || bindings.Count >= 3) + return; + + var binding = bindings[0]; + var prefixPropertyName = binding.propertyName.Split('.').First(); + + binding.isPhantom = true; + if (!bindings.Any(p => p.propertyName.EndsWith(".x"))) + { + binding.propertyName = prefixPropertyName + ".x"; + bindings.Insert(0, binding); + } + + if (!bindings.Any(p => p.propertyName.EndsWith(".y"))) + { + binding.propertyName = prefixPropertyName + ".y"; + bindings.Insert(1, binding); + } + + if (!bindings.Any(p => p.propertyName.EndsWith(".z"))) + { + binding.propertyName = prefixPropertyName + ".z"; + bindings.Insert(2, binding); + } + } + + + // make sure vectors and colors are sorted correctly in their subgroups + static int BindingSort(EditorCurveBinding b) + { + return AnimationWindowUtility.GetComponentIndex(b.propertyName); + } + + static int NamePrioritySort(ValueTuple> group) + { + if (group.Item1.Type != typeof(Transform)) + return 0; + + switch (group.Item1.GroupName) + { + case "Position" : return Int32.MinValue; + case "Rotation" : return Int32.MinValue+1; + case "Scale" : return Int32.MinValue+2; + default : return 0; + } + } + + static ValueTuple> CreateTuple(BindingGroup key, IEnumerable items) + { + return new ValueTuple>() + { + Item1 = key, + Item2 = items.ToList() + }; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingTreeViewDataSource.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingTreeViewDataSource.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..b553947b4fe8519d2af8b9052c48a1f1558c86b2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingTreeViewDataSource.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9c2177aaf0fde92439246adc2dc0bfa2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingTreeViewDataSourceGUI.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingTreeViewDataSourceGUI.cs new file mode 100644 index 0000000000000000000000000000000000000000..d9e4a70d4fb8d4b1361f39abd86d7f32ca332b02 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingTreeViewDataSourceGUI.cs @@ -0,0 +1,113 @@ +using System.Linq; +using UnityEditor.IMGUI.Controls; +using UnityEditorInternal; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class BindingTreeViewGUI : TreeViewGUI + { + static readonly float s_RowRightOffset = 10; + static readonly float s_ColorIndicatorTopMargin = 3; + static readonly Color s_KeyColorForNonCurves = new Color(0.7f, 0.7f, 0.7f, 0.5f); + static readonly Color s_ChildrenCurveLabelColor = new Color(1.0f, 1.0f, 1.0f, 0.7f); + static readonly Color s_PhantomPropertyLabelColor = new Color(0.0f, 0.8f, 0.8f, 1f); + static readonly Texture2D s_DefaultScriptTexture = EditorGUIUtility.LoadIcon("cs Script Icon"); + static readonly Texture2D s_TrackDefault = EditorGUIUtility.LoadIcon("UnityEngine/ScriptableObject Icon"); + + public BindingTreeViewGUI(TreeViewController treeView) + : base(treeView, true) + { + k_IconWidth = 13.0f; + iconOverlayGUI += OnItemIconOverlay; + } + + public override void OnRowGUI(Rect rowRect, TreeViewItem node, int row, bool selected, bool focused) + { + Color originalColor = GUI.color; + bool leafNode = node.parent != null && node.parent.id != BindingTreeViewDataSource.RootID && node.parent.id != BindingTreeViewDataSource.GroupID; + GUI.color = Color.white; + if (leafNode) + { + CurveTreeViewNode curveNode = node as CurveTreeViewNode; + if (curveNode != null && curveNode.bindings.Any() && curveNode.bindings.First().isPhantom) + GUI.color = s_PhantomPropertyLabelColor; + else + GUI.color = s_ChildrenCurveLabelColor; + } + + base.OnRowGUI(rowRect, node, row, selected, focused); + + GUI.color = originalColor; + DoCurveColorIndicator(rowRect, node as CurveTreeViewNode); + } + + protected override bool IsRenaming(int id) + { + return false; + } + + public override bool BeginRename(TreeViewItem item, float delay) + { + return false; + } + + static void DoCurveColorIndicator(Rect rect, CurveTreeViewNode node) + { + if (node == null) + return; + + if (Event.current.type != EventType.Repaint) + return; + + Color originalColor = GUI.color; + + if (node.bindings.Length == 1 && !node.bindings[0].isPPtrCurve) + GUI.color = CurveUtility.GetPropertyColor(node.bindings[0].propertyName); + else + GUI.color = s_KeyColorForNonCurves; + + Texture icon = CurveUtility.GetIconCurve(); + rect = new Rect(rect.xMax - s_RowRightOffset - (icon.width * 0.5f) - 5, rect.yMin + s_ColorIndicatorTopMargin, icon.width, icon.height); + + GUI.DrawTexture(rect, icon, ScaleMode.ScaleToFit, true, 1); + + GUI.color = originalColor; + } + + protected override Texture GetIconForItem(TreeViewItem item) + { + var node = item as CurveTreeViewNode; + if (node == null) + return null; + + var type = node.iconType; + if (type == null) + return null; + + // track type icon + if (typeof(TrackAsset).IsAssignableFrom(type)) + { + var icon = TrackResourceCache.GetTrackIconForType(type); + return icon == s_TrackDefault ? s_DefaultScriptTexture : icon; + } + + // custom clip icons always use the script texture + if (typeof(PlayableAsset).IsAssignableFrom(type)) + return s_DefaultScriptTexture; + + // this will return null for MonoBehaviours without a custom icon. + // use the scripting icon instead + return AssetPreview.GetMiniTypeThumbnail(type) ?? s_DefaultScriptTexture; + } + + static void OnItemIconOverlay(TreeViewItem item, Rect rect) + { + var curveNodeItem = item as CurveTreeViewNode; + if (curveNodeItem != null && curveNodeItem.iconOverlay != null) + GUI.Label(rect, curveNodeItem.iconOverlay); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingTreeViewDataSourceGUI.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingTreeViewDataSourceGUI.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2e16c1bd991732b03b5b43b6aa6ec660e118bafb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/BindingTreeViewDataSourceGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3c09dc5cd0a70cf40856b7d406106ee1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/ClipCurveEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/ClipCurveEditor.cs new file mode 100644 index 0000000000000000000000000000000000000000..751c9b46e3f3737890e1428a127922712aed0872 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/ClipCurveEditor.cs @@ -0,0 +1,386 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.Timeline; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor +{ + class ClipCurveEditor + { + + static readonly GUIContent s_RemoveCurveContent = new GUIContent(L10n.Tr("Remove Curve")); + static readonly GUIContent s_RemoveCurvesContent = new GUIContent(L10n.Tr("Remove Curves")); + + + internal readonly CurveEditor m_CurveEditor; + static readonly CurveEditorSettings s_CurveEditorSettings = new CurveEditorSettings + { + hSlider = false, + vSlider = false, + hRangeLocked = false, + vRangeLocked = false, + scaleWithWindow = true, + hRangeMin = 0.0f, + showAxisLabels = true, + allowDeleteLastKeyInCurve = true, + rectangleToolFlags = CurveEditorSettings.RectangleToolFlags.MiniRectangleTool + }; + + static readonly float s_GridLabelWidth = 40.0f; + + readonly BindingSelector m_BindingHierarchy; + public BindingSelector bindingHierarchy + { + get { return m_BindingHierarchy; } + } + + public Rect shownAreaInsideMargins + { + get { return m_CurveEditor != null ? m_CurveEditor.shownAreaInsideMargins : new Rect(1, 1, 1, 1); } + } + + Vector2 m_ScrollPosition = Vector2.zero; + + readonly CurveDataSource m_DataSource; + + float m_LastFrameRate = 30.0f; + + UInt64 m_LastClipVersion = UInt64.MaxValue; + + TrackViewModelData m_ViewModel; + bool m_ShouldRestoreShownArea; + + bool isNewSelection + { + get + { + if (m_ViewModel == null || m_DataSource == null) + return true; + + return m_ViewModel.lastInlineCurveDataID != m_DataSource.id; + } + } + + internal CurveEditor curveEditor + { + get { return m_CurveEditor; } + } + + public ClipCurveEditor(CurveDataSource dataSource, TimelineWindow parentWindow, TrackAsset hostTrack) + { + m_DataSource = dataSource; + + m_CurveEditor = new CurveEditor(new Rect(0, 0, 1000, 100), new CurveWrapper[0], false); + + s_CurveEditorSettings.vTickStyle = new TickStyle + { + tickColor = { color = DirectorStyles.Instance.customSkin.colorInlineCurveVerticalLines }, + distLabel = 20, + stubs = true + }; + + s_CurveEditorSettings.hTickStyle = new TickStyle + { + // hide horizontal lines by giving them a transparent color + tickColor = { color = new Color(0.0f, 0.0f, 0.0f, 0.0f) }, + distLabel = 0 + }; + + m_CurveEditor.settings = s_CurveEditorSettings; + + m_ViewModel = TimelineWindowViewPrefs.GetTrackViewModelData(hostTrack); + + m_ShouldRestoreShownArea = true; + m_CurveEditor.ignoreScrollWheelUntilClicked = true; + m_CurveEditor.curvesUpdated = OnCurvesUpdated; + + m_BindingHierarchy = new BindingSelector(parentWindow, m_CurveEditor, m_ViewModel.inlineCurvesState); + } + + public void SelectAllKeys() + { + m_CurveEditor.SelectAll(); + } + + public void FrameClip() + { + m_CurveEditor.InvalidateBounds(); + m_CurveEditor.FrameClip(false, true); + } + + public CurveDataSource dataSource + { + get { return m_DataSource; } + } + + // called when curves are edited + internal void OnCurvesUpdated() + { + if (m_DataSource == null) + return; + + if (m_CurveEditor == null) + return; + + if (m_CurveEditor.animationCurves.Length == 0) + return; + + List curvesToUpdate = m_CurveEditor.animationCurves.Where(c => c.changed).ToList(); + + // nothing changed, return. + if (curvesToUpdate.Count == 0) + return; + + // something changed, manage the undo properly. + m_DataSource.ApplyCurveChanges(curvesToUpdate); + m_LastClipVersion = m_DataSource.GetClipVersion(); + } + + public void DrawHeader(Rect headerRect) + { + m_BindingHierarchy.InitIfNeeded(headerRect, m_DataSource, isNewSelection); + + try + { + GUILayout.BeginArea(headerRect); + m_ScrollPosition = GUILayout.BeginScrollView(m_ScrollPosition, GUIStyle.none, GUI.skin.verticalScrollbar); + m_BindingHierarchy.OnGUI(new Rect(0, 0, headerRect.width, headerRect.height)); + if (m_BindingHierarchy.treeViewController != null) + m_BindingHierarchy.treeViewController.contextClickItemCallback = ContextClickItemCallback; + GUILayout.EndScrollView(); + GUILayout.EndArea(); + } + catch (Exception e) + { + Debug.LogException(e); + } + } + + void ContextClickItemCallback(int obj) + { + GenerateContextMenu(obj); + } + + void GenerateContextMenu(int obj = -1) + { + if (Event.current.type != EventType.ContextClick) + return; + + var selectedCurves = GetSelectedProperties().ToArray(); + if (selectedCurves.Length > 0) + { + var menu = new GenericMenu(); + var content = selectedCurves.Length == 1 ? s_RemoveCurveContent : s_RemoveCurvesContent; + menu.AddItem(content, + false, + () => RemoveCurves(selectedCurves) + ); + menu.ShowAsContext(); + } + } + + public IEnumerable GetSelectedProperties(bool useForcedGroups = false) + { + var bindings = new HashSet(); + var bindingTree = m_BindingHierarchy.treeViewController.data as BindingTreeViewDataSource; + foreach (var selectedId in m_BindingHierarchy.treeViewController.GetSelection()) + { + var node = bindingTree.FindItem(selectedId) as CurveTreeViewNode; + if (node == null) + continue; + + var curveNodeParent = node.parent as CurveTreeViewNode; + if (useForcedGroups && node.forceGroup && curveNodeParent != null) + bindings.UnionWith(curveNodeParent.bindings); + else + bindings.UnionWith(node.bindings); + } + return bindings; + } + + public void RemoveCurves(IEnumerable bindings) + { + m_DataSource.RemoveCurves(bindings); + m_BindingHierarchy.RefreshTree(); + TimelineWindow.instance.state.CalculateRowRects(); + m_LastClipVersion = m_DataSource.GetClipVersion(); + } + + class FrameFormatCurveEditorState : ICurveEditorState + { + public TimeArea.TimeFormat timeFormat + { + get { return TimeArea.TimeFormat.Frame; } + } + public Vector2 timeRange { get { return new Vector2(0, 1); } } + public bool rippleTime { get { return false; } } + } + + class UnformattedCurveEditorState : ICurveEditorState + { + public TimeArea.TimeFormat timeFormat + { + get { return TimeArea.TimeFormat.None; } + } + public Vector2 timeRange { get { return new Vector2(0, 1); } } + public bool rippleTime { get { return false; } } + } + + void UpdateCurveEditorIfNeeded(WindowState state) + { + if ((Event.current.type != EventType.Layout) || (m_DataSource == null) || (m_BindingHierarchy == null)) + return; + + // check if the curves have changed externally + var curveChange = m_DataSource.UpdateExternalChanges(ref m_LastClipVersion); + if (curveChange == CurveChangeType.None) + return; + + if (curveChange == CurveChangeType.CurveAddedOrRemoved) + m_BindingHierarchy.RefreshTree(); + else // curve modified + m_BindingHierarchy.RefreshCurves(); + + m_CurveEditor.InvalidateSelectionBounds(); + + if (state.timeInFrames) + m_CurveEditor.state = new FrameFormatCurveEditorState(); + else + m_CurveEditor.state = new UnformattedCurveEditorState(); + + m_CurveEditor.invSnap = state.referenceSequence.frameRate; + } + + public void DrawCurveEditor(Rect rect, WindowState state, Vector2 clipRange, bool loop, bool selected) + { + SetupMarginsAndRect(rect, state); + UpdateCurveEditorIfNeeded(state); + + if (m_ShouldRestoreShownArea) + RestoreShownArea(); + + var curveVisibleTimeRange = CalculateCurveVisibleTimeRange(state.timeAreaShownRange, m_DataSource); + m_CurveEditor.SetShownHRangeInsideMargins(curveVisibleTimeRange.x, curveVisibleTimeRange.y); //align the curve with the clip. + + if (m_LastFrameRate != state.referenceSequence.frameRate) + { + m_CurveEditor.hTicks.SetTickModulosForFrameRate(state.referenceSequence.frameRate); + m_LastFrameRate = state.referenceSequence.frameRate; + } + + foreach (var cw in m_CurveEditor.animationCurves) + cw.renderer.SetWrap(WrapMode.Default, loop ? WrapMode.Loop : WrapMode.Default); + + using (new GUIGroupScope(rect)) + { + var localRect = new Rect(0.0f, 0.0f, rect.width, rect.height); + var localClipRange = new Vector2(Mathf.Floor(clipRange.x - rect.xMin), Mathf.Ceil(clipRange.y - rect.xMin)); + var curveStartPosX = Mathf.Floor(state.TimeToPixel(m_DataSource.start) - rect.xMin); + + EditorGUI.DrawRect(new Rect(curveStartPosX, 0.0f, 1.0f, rect.height), new Color(1.0f, 1.0f, 1.0f, 0.5f)); + DrawCurveEditorBackground(localRect); + + if (selected) + { + var selectionRect = new Rect(localClipRange.x, 0.0f, localClipRange.y - localClipRange.x, localRect.height); + DrawOutline(selectionRect); + } + + EditorGUI.BeginChangeCheck(); + { + var evt = Event.current; + if (evt.type == EventType.Layout || evt.type == EventType.Repaint || selected) + m_CurveEditor.CurveGUI(); + } + if (EditorGUI.EndChangeCheck()) + OnCurvesUpdated(); + + DrawOverlay(localRect, localClipRange, DirectorStyles.Instance.customSkin.colorInlineCurveOutOfRangeOverlay); + DrawGrid(localRect, curveStartPosX); + } + } + + static Vector2 CalculateCurveVisibleTimeRange(Vector2 timeAreaShownRange, CurveDataSource curve) + { + var curveVisibleTimeRange = new Vector2 + { + x = Math.Max(0.0f, timeAreaShownRange.x - curve.start), + y = timeAreaShownRange.y - curve.start + }; + return curveVisibleTimeRange * curve.timeScale; + } + + void SetupMarginsAndRect(Rect rect, WindowState state) + { + var startX = state.TimeToPixel(m_DataSource.start) - rect.x; + var timelineWidth = state.timeAreaRect.width; + m_CurveEditor.rect = new Rect(0.0f, 0.0f, timelineWidth, rect.height); + m_CurveEditor.leftmargin = Math.Max(startX, 0.0f); + m_CurveEditor.rightmargin = 0.0f; + m_CurveEditor.topmargin = m_CurveEditor.bottommargin = CalculateTopMargin(rect.height); + } + + void RestoreShownArea() + { + if (isNewSelection) + FrameClip(); + else + m_CurveEditor.shownAreaInsideMargins = m_ViewModel.inlineCurvesShownAreaInsideMargins; + m_ShouldRestoreShownArea = false; + } + + static void DrawCurveEditorBackground(Rect rect) + { + if (EditorGUIUtility.isProSkin) + return; + + var animEditorBackgroundRect = Rect.MinMaxRect(0.0f, rect.yMin, rect.xMax, rect.yMax); + + // Curves are not legible in Personal Skin so we need to darken the background a bit. + EditorGUI.DrawRect(animEditorBackgroundRect, DirectorStyles.Instance.customSkin.colorInlineCurvesBackground); + } + + static float CalculateTopMargin(float height) + { + return Mathf.Clamp(0.15f * height, 10.0f, 40.0f); + } + + static void DrawOutline(Rect rect, float thickness = 2.0f) + { + // Draw top selected lines. + EditorGUI.DrawRect(new Rect(rect.xMin, rect.yMin, rect.width, thickness), Color.white); + + // Draw bottom selected lines. + EditorGUI.DrawRect(new Rect(rect.xMin, rect.yMax - thickness, rect.width, thickness), Color.white); + + // Draw Left Selected Lines + EditorGUI.DrawRect(new Rect(rect.xMin, rect.yMin, thickness, rect.height), Color.white); + + // Draw Right Selected Lines + EditorGUI.DrawRect(new Rect(rect.xMax - thickness, rect.yMin, thickness, rect.height), Color.white); + } + + static void DrawOverlay(Rect rect, Vector2 clipRange, Color color) + { + var leftSide = new Rect(rect.xMin, rect.yMin, clipRange.x - rect.xMin, rect.height); + EditorGUI.DrawRect(leftSide, color); + + var rightSide = new Rect(Mathf.Max(0.0f, clipRange.y), rect.yMin, rect.xMax, rect.height); + EditorGUI.DrawRect(rightSide, color); + } + + void DrawGrid(Rect rect, float curveXPosition) + { + var gridXPos = Mathf.Max(curveXPosition - s_GridLabelWidth, rect.xMin); + var gridRect = new Rect(gridXPos, rect.y, s_GridLabelWidth, rect.height); + var originalRect = m_CurveEditor.rect; + + m_CurveEditor.rect = new Rect(0.0f, 0.0f, rect.width, rect.height); + using (new GUIGroupScope(gridRect)) + m_CurveEditor.GridGUI(); + m_CurveEditor.rect = originalRect; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/ClipCurveEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/ClipCurveEditor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5ae80d24d598baa8a459e28c643d7cb84c149e50 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/ClipCurveEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d49b2ed20045e034f9cdf6a6d95e6183 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurveDataSource.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurveDataSource.cs new file mode 100644 index 0000000000000000000000000000000000000000..6e8d4ba93d2a675742dfc6d11626116929c6a04c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurveDataSource.cs @@ -0,0 +1,439 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + enum CurveChangeType + { + None, + CurveModified, + CurveAddedOrRemoved + } + + abstract class CurveDataSource + { + public static CurveDataSource Create(IRowGUI trackGUI) + { + if (trackGUI.asset is AnimationTrack) + return new InfiniteClipCurveDataSource(trackGUI); + + return new TrackParametersCurveDataSource(trackGUI); + } + + public static CurveDataSource Create(TimelineClipGUI clipGUI) + { + if (clipGUI.clip.animationClip != null) + return new ClipAnimationCurveDataSource(clipGUI); + + return new ClipParametersCurveDataSource(clipGUI); + } + + int? m_ID = null; + public int id + { + get + { + if (!m_ID.HasValue) + m_ID = CreateHashCode(); + + return m_ID.Value; + } + } + + readonly IRowGUI m_TrackGUI; + protected CurveDataSource(IRowGUI trackGUI) + { + m_TrackGUI = trackGUI; + } + + public abstract AnimationClip animationClip { get; } + + public abstract float start { get; } + public abstract float timeScale { get; } + public abstract string groupingName { get; } + + // Applies changes from the visual curve in the curve wrapper back to the animation clips + public virtual void ApplyCurveChanges(IEnumerable updatedCurves) + { + Undo.RegisterCompleteObjectUndo(animationClip, "Edit Clip Curve"); + foreach (CurveWrapper c in updatedCurves) + { + if (c.curve.length > 0) + AnimationUtility.SetEditorCurve(animationClip, c.binding, c.curve); + else + RemoveCurves(new[] {c.binding}); + c.changed = false; + } + } + + /// The clip version is a value that will change when a curve gets updated. + /// it's used to detect when an animation clip has been changed externally + /// A versioning value indicating the state of the curve. If the curve is updated externally this value will change. + public virtual UInt64 GetClipVersion() + { + return animationClip.ClipVersion(); + } + + /// Call this method to check if the underlying clip has changed + /// A versioning value. This will be updated to the latest version + /// A value indicating how the clip has changed + public virtual CurveChangeType UpdateExternalChanges(ref UInt64 curveVersion) + { + return animationClip.GetChangeType(ref curveVersion); + } + + public virtual string ModifyPropertyDisplayName(string path, string propertyName) => propertyName; + + public virtual void RemoveCurves(IEnumerable bindings) + { + Undo.RegisterCompleteObjectUndo(animationClip, "Remove Curve(s)"); + foreach(var binding in bindings) + { + if (binding.isPPtrCurve) + AnimationUtility.SetObjectReferenceCurve(animationClip, binding, null); + else + AnimationUtility.SetEditorCurve(animationClip, binding, null); + } + } + + public Rect GetBackgroundRect(WindowState state) + { + var trackRect = m_TrackGUI.boundingRect; + return new Rect( + state.timeAreaTranslation.x + trackRect.xMin, + trackRect.y, + (float)state.editSequence.asset.duration * state.timeAreaScale.x, + trackRect.height + ); + } + + public List GenerateWrappers(IEnumerable bindings) + { + var wrappers = new List(bindings.Count()); + int curveWrapperId = 0; + + foreach (EditorCurveBinding b in bindings) + { + // General configuration + var wrapper = new CurveWrapper + { + id = curveWrapperId++, + binding = b, + groupId = -1, + hidden = false, + readOnly = false, + getAxisUiScalarsCallback = () => new Vector2(1, 1) + }; + + // Specific configuration + ConfigureCurveWrapper(wrapper); + + wrappers.Add(wrapper); + } + + return wrappers; + } + + protected virtual void ConfigureCurveWrapper(CurveWrapper wrapper) + { + wrapper.color = CurveUtility.GetPropertyColor(wrapper.binding.propertyName); + wrapper.renderer = new NormalCurveRenderer(AnimationUtility.GetEditorCurve(animationClip, wrapper.binding)); + wrapper.renderer.SetCustomRange(0.0f, animationClip.length); + } + + protected virtual int CreateHashCode() + { + return m_TrackGUI.asset.GetHashCode(); + } + } + + class ClipAnimationCurveDataSource : CurveDataSource + { + static readonly string k_GroupingName = L10n.Tr("Animated Values"); + + readonly TimelineClipGUI m_ClipGUI; + + public ClipAnimationCurveDataSource(TimelineClipGUI clipGUI) : base(clipGUI.parent) + { + m_ClipGUI = clipGUI; + } + + public override AnimationClip animationClip + { + get { return m_ClipGUI.clip.animationClip; } + } + + public override float start + { + get { return (float)m_ClipGUI.clip.FromLocalTimeUnbound(0.0); } + } + + public override float timeScale + { + get { return (float)m_ClipGUI.clip.timeScale; } + } + + public override string groupingName + { + get { return k_GroupingName; } + } + + protected override int CreateHashCode() + { + return base.CreateHashCode().CombineHash(m_ClipGUI.clip.GetHashCode()); + } + + public override string ModifyPropertyDisplayName(string path, string propertyName) + { + if (!AnimatedPropertyUtility.IsMaterialProperty(propertyName)) + return propertyName; + + var track = m_ClipGUI.clip.parentTrack; + if (track == null) + return propertyName; + + var gameObjectBinding = TimelineUtility.GetSceneGameObject(TimelineEditor.inspectedDirector, track); + if (gameObjectBinding == null) + return propertyName; + + if (!string.IsNullOrEmpty(path)) + { + var transform = gameObjectBinding.transform.Find(path); + if (transform == null) + return propertyName; + gameObjectBinding = transform.gameObject; + } + + return AnimatedPropertyUtility.RemapMaterialName(gameObjectBinding, propertyName); + } + } + + class ClipParametersCurveDataSource : CurveDataSource + { + static readonly string k_GroupingName = L10n.Tr("Clip Properties"); + + readonly TimelineClipGUI m_ClipGUI; + readonly CurvesProxy m_CurvesProxy; + + private int m_ClipDirtyVersion; + + public ClipParametersCurveDataSource(TimelineClipGUI clipGUI) : base(clipGUI.parent) + { + m_ClipGUI = clipGUI; + m_CurvesProxy = new CurvesProxy(clipGUI.clip); + } + + public override AnimationClip animationClip + { + get { return m_CurvesProxy.curves; } + } + + public override UInt64 GetClipVersion() + { + return sourceAnimationClip.ClipVersion(); + } + + public override CurveChangeType UpdateExternalChanges(ref ulong curveVersion) + { + if (m_ClipGUI == null || m_ClipGUI.clip == null) + return CurveChangeType.None; + + var changeType = sourceAnimationClip.GetChangeType(ref curveVersion); + if (changeType != CurveChangeType.None) + { + m_CurvesProxy.ApplyExternalChangesToProxy(); + } + else if (m_ClipDirtyVersion != m_ClipGUI.clip.DirtyIndex) + { + m_CurvesProxy.UpdateProxyCurves(); + if (changeType == CurveChangeType.None) + changeType = CurveChangeType.CurveModified; + } + m_ClipDirtyVersion = m_ClipGUI.clip.DirtyIndex; + return changeType; + } + + public override float start + { + get { return (float)m_ClipGUI.clip.FromLocalTimeUnbound(0.0); } + } + + public override float timeScale + { + get { return (float)m_ClipGUI.clip.timeScale; } + } + + public override string groupingName + { + get { return k_GroupingName; } + } + + public override void RemoveCurves(IEnumerable bindings) + { + m_CurvesProxy.RemoveCurves(bindings); + } + + public override void ApplyCurveChanges(IEnumerable updatedCurves) + { + m_CurvesProxy.UpdateCurves(updatedCurves); + } + + protected override void ConfigureCurveWrapper(CurveWrapper wrapper) + { + m_CurvesProxy.ConfigureCurveWrapper(wrapper); + } + + protected override int CreateHashCode() + { + return base.CreateHashCode().CombineHash(m_ClipGUI.clip.GetHashCode()); + } + + private AnimationClip sourceAnimationClip + { + get + { + if (m_ClipGUI == null || m_ClipGUI.clip == null || m_ClipGUI.clip.curves == null) + return null; + return m_ClipGUI.clip.curves; + } + } + } + + class InfiniteClipCurveDataSource : CurveDataSource + { + static readonly string k_GroupingName = L10n.Tr("Animated Values"); + + readonly AnimationTrack m_AnimationTrack; + + public InfiniteClipCurveDataSource(IRowGUI trackGui) : base(trackGui) + { + m_AnimationTrack = trackGui.asset as AnimationTrack; + } + + public override AnimationClip animationClip + { + get { return m_AnimationTrack.infiniteClip; } + } + + public override float start + { + get { return 0.0f; } + } + + public override float timeScale + { + get { return 1.0f; } + } + + public override string groupingName + { + get { return k_GroupingName; } + } + + public override string ModifyPropertyDisplayName(string path, string propertyName) + { + if (m_AnimationTrack == null || !AnimatedPropertyUtility.IsMaterialProperty(propertyName)) + return propertyName; + + var binding = m_AnimationTrack.GetBinding(TimelineEditor.inspectedDirector); + if (binding == null) + return propertyName; + + var target = binding.transform; + if (!string.IsNullOrEmpty(path)) + target = target.Find(path); + + if (target == null) + return propertyName; + + return AnimatedPropertyUtility.RemapMaterialName(target.gameObject, propertyName); + } + } + + class TrackParametersCurveDataSource : CurveDataSource + { + static readonly string k_GroupingName = L10n.Tr("Track Properties"); + + readonly CurvesProxy m_CurvesProxy; + private int m_TrackDirtyVersion; + + public TrackParametersCurveDataSource(IRowGUI trackGui) : base(trackGui) + { + m_CurvesProxy = new CurvesProxy(trackGui.asset); + } + + public override AnimationClip animationClip + { + get { return m_CurvesProxy.curves; } + } + + public override UInt64 GetClipVersion() + { + return sourceAnimationClip.ClipVersion(); + } + + public override CurveChangeType UpdateExternalChanges(ref ulong curveVersion) + { + if (m_CurvesProxy.targetTrack == null) + return CurveChangeType.None; + + var changeType = sourceAnimationClip.GetChangeType(ref curveVersion); + if (changeType != CurveChangeType.None) + { + m_CurvesProxy.ApplyExternalChangesToProxy(); + } + // track property has changed externally, update the curve proxies + else if (m_TrackDirtyVersion != m_CurvesProxy.targetTrack.DirtyIndex) + { + if (changeType == CurveChangeType.None) + changeType = CurveChangeType.CurveModified; + m_CurvesProxy.UpdateProxyCurves(); + } + m_TrackDirtyVersion = m_CurvesProxy.targetTrack.DirtyIndex; + return changeType; + } + + public override float start + { + get { return 0.0f; } + } + + public override float timeScale + { + get { return 1.0f; } + } + + public override string groupingName + { + get { return k_GroupingName; } + } + + public override void RemoveCurves(IEnumerable bindings) + { + m_CurvesProxy.RemoveCurves(bindings); + } + + public override void ApplyCurveChanges(IEnumerable updatedCurves) + { + m_CurvesProxy.UpdateCurves(updatedCurves); + } + + protected override void ConfigureCurveWrapper(CurveWrapper wrapper) + { + m_CurvesProxy.ConfigureCurveWrapper(wrapper); + } + + private AnimationClip sourceAnimationClip + { + get + { + if (m_CurvesProxy.targetTrack == null || m_CurvesProxy.targetTrack.curves == null) + return null; + return m_CurvesProxy.targetTrack.curves; + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurveDataSource.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurveDataSource.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..6416ecfbe8e9d700d5cc0372a7006df2c5eca7f2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurveDataSource.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 87a1ae9719ec25d44a4dbec20ec0f892 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurveTreeViewNode.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurveTreeViewNode.cs new file mode 100644 index 0000000000000000000000000000000000000000..c1f05df58d561245995de195bb32f9c5340f20ac --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurveTreeViewNode.cs @@ -0,0 +1,39 @@ +using System.Linq; +using UnityEditor.IMGUI.Controls; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class CurveTreeViewNode : TreeViewItem + { + public bool forceGroup { get; } + public System.Type iconType { get; } + public GUIContent iconOverlay { get; } + + EditorCurveBinding[] m_Bindings; + + public EditorCurveBinding[] bindings + { + get { return m_Bindings; } + } + + public CurveTreeViewNode(int id, TreeViewItem parent, string displayName, EditorCurveBinding[] bindings, bool _forceGroup = false) + : base(id, parent != null ? parent.depth + 1 : -1, parent, displayName) + { + m_Bindings = bindings; + forceGroup = _forceGroup; + + + // capture the preview icon type. If all subbindings are the same type, use that. Otherwise use null as a default + iconType = null; + if (parent != null && parent.depth >= 0 && bindings != null && bindings.Length > 0 && bindings.All(b => b.type == bindings[0].type)) + { + iconType = bindings[0].type; + + // for components put the component type in a tooltip + if (iconType != null && typeof(Component).IsAssignableFrom(iconType)) + iconOverlay = new GUIContent(string.Empty, ObjectNames.NicifyVariableName(iconType.Name)); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurveTreeViewNode.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurveTreeViewNode.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2a65961547374179d3eef653a81b203d7249cd06 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurveTreeViewNode.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: 1ec45eaf72174ca189827d7896952167 +timeCreated: 1599683561 \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurvesProxy.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurvesProxy.cs new file mode 100644 index 0000000000000000000000000000000000000000..d890b8c3372eb51258ad3187d40f8c9d84d37e48 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurvesProxy.cs @@ -0,0 +1,360 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using JetBrains.Annotations; +using UnityEngine; +using UnityEngine.Timeline; +using UnityObject = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class CurvesProxy : ICurvesOwner + { + public AnimationClip curves + { + get { return proxyCurves != null ? proxyCurves : m_OriginalOwner.curves; } + } + + public bool hasCurves + { + get { return m_IsAnimatable || m_OriginalOwner.hasCurves; } + } + + public double duration + { + get { return m_OriginalOwner.duration; } + } + + public string defaultCurvesName + { + get { return m_OriginalOwner.defaultCurvesName; } + } + + public UnityObject asset + { + get { return m_OriginalOwner.asset; } + } + + public UnityObject assetOwner + { + get { return m_OriginalOwner.assetOwner; } + } + + public TrackAsset targetTrack + { + get { return m_OriginalOwner.targetTrack; } + } + + readonly ICurvesOwner m_OriginalOwner; + readonly bool m_IsAnimatable; + readonly Dictionary m_PropertiesMap = new Dictionary(); + int m_ProxyIsRebuilding = 0; + + AnimationClip m_ProxyCurves; + AnimationClip proxyCurves + { + get + { + if (!m_IsAnimatable) return null; + + if (m_ProxyCurves == null) + RebuildProxyCurves(); + + return m_ProxyCurves; + } + } + + public CurvesProxy([NotNull] ICurvesOwner originalOwner) + { + m_OriginalOwner = originalOwner; + m_IsAnimatable = originalOwner.HasAnyAnimatableParameters(); + + RebuildProxyCurves(); + } + + public void CreateCurves(string curvesClipName) + { + m_OriginalOwner.CreateCurves(curvesClipName); + } + + public void ConfigureCurveWrapper(CurveWrapper wrapper) + { + var color = CurveUtility.GetPropertyColor(wrapper.binding.propertyName); + wrapper.color = color; + + float h, s, v; + Color.RGBToHSV(color, out h, out s, out v); + wrapper.wrapColorMultiplier = Color.HSVToRGB(h, s * 0.33f, v * 1.15f); + + var curve = AnimationUtility.GetEditorCurve(proxyCurves, wrapper.binding); + + wrapper.renderer = new NormalCurveRenderer(curve); + + // Use curve length instead of animation clip length + wrapper.renderer.SetCustomRange(0.0f, curve.keys.Last().time); + } + + public void RebuildCurves() + { + RebuildProxyCurves(); + } + + public void RemoveCurves(IEnumerable bindings) + { + if (m_ProxyIsRebuilding > 0 || !m_OriginalOwner.hasCurves) + return; + + Undo.RegisterCompleteObjectUndo(m_OriginalOwner.curves, L10n.Tr("Remove Clip Curve")); + foreach (var binding in bindings) + AnimationUtility.SetEditorCurve(m_OriginalOwner.curves, binding, null); + m_OriginalOwner.SanitizeCurvesData(); + RebuildProxyCurves(); + } + + public void UpdateCurves(IEnumerable updatedCurves) + { + if (m_ProxyIsRebuilding > 0) + return; + + Undo.RegisterCompleteObjectUndo(m_OriginalOwner.asset, "Edit Clip Curve"); + if (m_OriginalOwner.curves != null) + Undo.RegisterCompleteObjectUndo(m_OriginalOwner.curves, "Edit Clip Curve"); + + var requireRebuild = false; + foreach (var curve in updatedCurves) + { + requireRebuild |= curve.curve.length == 0; + UpdateCurve(curve.binding, curve.curve); + } + + if (requireRebuild) + m_OriginalOwner.SanitizeCurvesData(); + + AnimatedParameterUtility.UpdateSerializedPlayableAsset(m_OriginalOwner.asset); + } + + public void ApplyExternalChangesToProxy() + { + using (new RebuildGuard(this)) + { + if (m_OriginalOwner.curves == null) + return; + + var curveInfo = AnimationClipCurveCache.Instance.GetCurveInfo(m_OriginalOwner.curves); + for (int i = 0; i < curveInfo.bindings.Length; i++) + { + if (curveInfo.curves[i] != null && curveInfo.curves.Length != 0) + { + if (m_PropertiesMap.TryGetValue(curveInfo.bindings[i], out var prop) && AnimatedParameterUtility.IsParameterAnimatable(prop)) + AnimationUtility.SetEditorCurve(m_ProxyCurves, curveInfo.bindings[i], curveInfo.curves[i]); + } + } + } + } + + void UpdateCurve(EditorCurveBinding binding, AnimationCurve curve) + { + ApplyConstraints(binding, curve); + + if (curve.length == 0) + { + HandleAllKeysDeleted(binding); + return; + } + + // there is no curve in the animation clip, this is a proxy curve + if (IsConstantCurve(binding, curve)) + HandleConstantCurveValueChanged(binding, curve); + else + HandleCurveUpdated(binding, curve); + } + + bool IsConstantCurve(EditorCurveBinding binding, AnimationCurve curve) + { + if (curve.length != 1) + return false; + return m_OriginalOwner.curves == null || AnimationUtility.GetEditorCurve(m_OriginalOwner.curves, binding) == null; + } + + 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(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); + } + } + + void HandleCurveUpdated(EditorCurveBinding binding, AnimationCurve updatedCurve) + { + if (!m_OriginalOwner.hasCurves) + m_OriginalOwner.CreateCurves(null); + + AnimationUtility.SetEditorCurve(m_OriginalOwner.curves, binding, updatedCurve); + AnimationUtility.SetEditorCurve(m_ProxyCurves, binding, updatedCurve); + } + + void HandleConstantCurveValueChanged(EditorCurveBinding binding, AnimationCurve updatedCurve) + { + var prop = m_PropertiesMap[binding]; + if (prop == null) + return; + + Undo.RegisterCompleteObjectUndo(prop.serializedObject.targetObject, "Edit Clip Curve"); + prop.serializedObject.UpdateIfRequiredOrScript(); + CurveEditUtility.SetFromKeyValue(prop, updatedCurve.keys[0].value); + prop.serializedObject.ApplyModifiedProperties(); + + AnimationUtility.SetEditorCurve(m_ProxyCurves, binding, updatedCurve); + } + + void HandleAllKeysDeleted(EditorCurveBinding binding) + { + if (m_OriginalOwner.hasCurves) + { + // Remove curve from original asset + AnimationUtility.SetEditorCurve(m_OriginalOwner.curves, binding, null); + SetProxyCurve(m_PropertiesMap[binding], binding); + } + } + + void RebuildProxyCurves() + { + if (!m_IsAnimatable) + return; + + using (new RebuildGuard(this)) + { + if (m_ProxyCurves == null) + { + m_ProxyCurves = new AnimationClip + { + legacy = true, + name = "Constant Curves", + hideFlags = HideFlags.HideAndDontSave, + frameRate = m_OriginalOwner.targetTrack.timelineAsset == null + ? TimelineAsset.EditorSettings.kDefaultFps + : m_OriginalOwner.targetTrack.timelineAsset.editorSettings.fps + }; + } + else + { + m_ProxyCurves.ClearCurves(); + } + + m_OriginalOwner.SanitizeCurvesData(); + AnimatedParameterUtility.UpdateSerializedPlayableAsset(m_OriginalOwner.asset); + var parameters = m_OriginalOwner.GetAllAnimatableParameters().ToArray(); + foreach (var param in parameters) + CreateProxyCurve(param, m_ProxyCurves, m_OriginalOwner.asset, param.propertyPath); + + AnimationClipCurveCache.Instance.GetCurveInfo(m_ProxyCurves).dirty = true; + } + } + + // updates the just the proxied values. This can be called when the asset changes, so the proxy values are properly updated + public void UpdateProxyCurves() + { + if (!m_IsAnimatable || m_ProxyCurves == null || m_ProxyCurves.empty) + return; + + AnimatedParameterUtility.UpdateSerializedPlayableAsset(m_OriginalOwner.asset); + var parameters = m_OriginalOwner.GetAllAnimatableParameters().ToArray(); + using (new RebuildGuard(this)) + { + if (m_OriginalOwner.hasCurves) + { + var bindingInfo = AnimationClipCurveCache.Instance.GetCurveInfo(m_OriginalOwner.curves); + foreach (var param in parameters) + { + var binding = AnimatedParameterUtility.GetCurveBinding(m_OriginalOwner.asset, param.propertyPath); + if (!bindingInfo.bindings.Contains(binding, AnimationPreviewUtilities.EditorCurveBindingComparer.Instance)) + SetProxyCurve(param, AnimatedParameterUtility.GetCurveBinding(m_OriginalOwner.asset, param.propertyPath)); + } + } + else + { + foreach (var param in parameters) + SetProxyCurve(param, AnimatedParameterUtility.GetCurveBinding(m_OriginalOwner.asset, param.propertyPath)); + } + } + + AnimationClipCurveCache.Instance.GetCurveInfo(m_ProxyCurves).dirty = true; + } + + void CreateProxyCurve(SerializedProperty prop, AnimationClip clip, UnityObject owner, string propertyName) + { + var binding = AnimatedParameterUtility.GetCurveBinding(owner, propertyName); + + var originalCurve = m_OriginalOwner.hasCurves + ? AnimationUtility.GetEditorCurve(m_OriginalOwner.curves, binding) + : null; + + if (originalCurve != null) + { + AnimationUtility.SetEditorCurve(clip, binding, originalCurve); + } + else + { + SetProxyCurve(prop, binding); + } + + m_PropertiesMap[binding] = prop; + } + + void SetProxyCurve(SerializedProperty prop, EditorCurveBinding binding) + { + var curve = new AnimationCurve(); + CurveEditUtility.AddKeyFrameToCurve( + curve, 0.0f, m_ProxyCurves.frameRate, CurveEditUtility.GetKeyValue(prop), + prop.propertyType == SerializedPropertyType.Boolean); + AnimationUtility.SetEditorCurve(m_ProxyCurves, binding, curve); + } + + + + struct RebuildGuard : IDisposable + { + CurvesProxy m_Owner; + AnimationUtility.OnCurveWasModified m_Callback; + + public RebuildGuard(CurvesProxy owner) + { + m_Callback = AnimationUtility.onCurveWasModified; + AnimationUtility.onCurveWasModified = null; + m_Owner = owner; + m_Owner.m_ProxyIsRebuilding++; + } + + public void Dispose() + { + AnimationUtility.onCurveWasModified = m_Callback; + m_Owner.m_ProxyIsRebuilding--; + m_Owner = null; + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurvesProxy.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurvesProxy.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..18e3029e3bd309aeb1fbf9a99330c6794a14789b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/CurvesProxy.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d72ccd2c66ea846fc842adf682b11526 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/TimelineAnimationUtilities.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/TimelineAnimationUtilities.cs new file mode 100644 index 0000000000000000000000000000000000000000..f3ca1ae74fea3d0509cd17806b8dff263634fddc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/TimelineAnimationUtilities.cs @@ -0,0 +1,435 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEditor; +using UnityEngineInternal; +using UnityEngine.Timeline; +using UnityEngine.Playables; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class TimelineAnimationUtilities + { + public enum OffsetEditMode + { + None = -1, + Translation = 0, + Rotation = 1 + } + + public static bool ValidateOffsetAvailabitity(PlayableDirector director, Animator animator) + { + if (director == null || animator == null) + return false; + + return true; + } + + public static TimelineClip GetPreviousClip(TimelineClip clip) + { + TimelineClip previousClip = null; + foreach (var c in clip.parentTrack.clips) + { + if (c.start < clip.start && (previousClip == null || c.start >= previousClip.start)) + previousClip = c; + } + return previousClip; + } + + public static TimelineClip GetNextClip(TimelineClip clip) + { + return clip.parentTrack.clips.Where(c => c.start > clip.start).OrderBy(c => c.start).FirstOrDefault(); + } + + public struct RigidTransform + { + public Vector3 position; + public Quaternion rotation; + + public static RigidTransform Compose(Vector3 pos, Quaternion rot) + { + RigidTransform ret; + ret.position = pos; + ret.rotation = rot; + return ret; + } + + public static RigidTransform Mul(RigidTransform a, RigidTransform b) + { + RigidTransform ret; + ret.rotation = a.rotation * b.rotation; + ret.position = a.position + a.rotation * b.position; + return ret; + } + + public static RigidTransform Inverse(RigidTransform a) + { + RigidTransform ret; + ret.rotation = Quaternion.Inverse(a.rotation); + ret.position = ret.rotation * (-a.position); + return ret; + } + + public static RigidTransform identity + { + get { return Compose(Vector3.zero, Quaternion.identity); } + } + } + + + private static Matrix4x4 GetTrackMatrix(Transform transform, AnimationTrack track) + { + Matrix4x4 trackMatrix = Matrix4x4.TRS(track.position, track.rotation, Vector3.one); + + // in scene off mode, the track offsets are set to the preview position which is stored in the track + if (track.trackOffset == TrackOffset.ApplySceneOffsets) + { + trackMatrix = Matrix4x4.TRS(track.sceneOffsetPosition, Quaternion.Euler(track.sceneOffsetRotation), Vector3.one); + } + + // put the parent transform on to the track matrix + if (transform.parent != null) + { + trackMatrix = transform.parent.localToWorldMatrix * trackMatrix; + } + + return trackMatrix; + } + + // Given a world space position and rotation, updates the clip offsets to match that + public static RigidTransform UpdateClipOffsets(AnimationPlayableAsset asset, AnimationTrack track, Transform transform, Vector3 globalPosition, Quaternion globalRotation) + { + Matrix4x4 worldToLocal = transform.worldToLocalMatrix; + Matrix4x4 clipMatrix = Matrix4x4.TRS(asset.position, asset.rotation, Vector3.one); + Matrix4x4 trackMatrix = GetTrackMatrix(transform, track); + + + // Use the transform to find the proper goal matrix with scale taken into account + var oldPos = transform.position; + var oldRot = transform.rotation; + transform.position = globalPosition; + transform.rotation = globalRotation; + Matrix4x4 goal = transform.localToWorldMatrix; + transform.position = oldPos; + transform.rotation = oldRot; + + // compute the new clip matrix. + Matrix4x4 newClip = trackMatrix.inverse * goal * worldToLocal * trackMatrix * clipMatrix; + return RigidTransform.Compose(newClip.GetColumn(3), MathUtils.QuaternionFromMatrix(newClip)); + } + + public static RigidTransform GetTrackOffsets(AnimationTrack track, Transform transform) + { + Vector3 position = track.position; + Quaternion rotation = track.rotation; + if (transform != null && transform.parent != null) + { + position = transform.parent.TransformPoint(position); + rotation = transform.parent.rotation * rotation; + MathUtils.QuaternionNormalize(ref rotation); + } + + return RigidTransform.Compose(position, rotation); + } + + public static void UpdateTrackOffset(AnimationTrack track, Transform transform, RigidTransform offsets) + { + if (transform != null && transform.parent != null) + { + offsets.position = transform.parent.InverseTransformPoint(offsets.position); + offsets.rotation = Quaternion.Inverse(transform.parent.rotation) * offsets.rotation; + MathUtils.QuaternionNormalize(ref offsets.rotation); + } + + track.position = offsets.position; + track.eulerAngles = AnimationUtility.GetClosestEuler(offsets.rotation, track.eulerAngles, RotationOrder.OrderZXY); + track.UpdateClipOffsets(); + } + + static MatchTargetFields GetMatchFields(TimelineClip clip) + { + var track = clip.parentTrack as AnimationTrack; + if (track == null) + return MatchTargetFieldConstants.None; + + var asset = clip.asset as AnimationPlayableAsset; + var fields = track.matchTargetFields; + if (asset != null && !asset.useTrackMatchFields) + fields = asset.matchTargetFields; + return fields; + } + + static void WriteMatchFields(AnimationPlayableAsset asset, RigidTransform result, MatchTargetFields fields) + { + Vector3 position = asset.position; + + position.x = fields.HasAny(MatchTargetFields.PositionX) ? result.position.x : position.x; + position.y = fields.HasAny(MatchTargetFields.PositionY) ? result.position.y : position.y; + position.z = fields.HasAny(MatchTargetFields.PositionZ) ? result.position.z : position.z; + + asset.position = position; + + // check first to avoid unnecessary conversion errors + if (fields.HasAny(MatchTargetFieldConstants.Rotation)) + { + Vector3 eulers = asset.eulerAngles; + Vector3 resultEulers = result.rotation.eulerAngles; + + eulers.x = fields.HasAny(MatchTargetFields.RotationX) ? resultEulers.x : eulers.x; + eulers.y = fields.HasAny(MatchTargetFields.RotationY) ? resultEulers.y : eulers.y; + eulers.z = fields.HasAny(MatchTargetFields.RotationZ) ? resultEulers.z : eulers.z; + + asset.eulerAngles = AnimationUtility.GetClosestEuler(Quaternion.Euler(eulers), asset.eulerAngles, RotationOrder.OrderZXY); + } + } + + public static void MatchPrevious(TimelineClip currentClip, Transform matchPoint, PlayableDirector director) + { + const double timeEpsilon = 0.00001; + MatchTargetFields matchFields = GetMatchFields(currentClip); + if (matchFields == MatchTargetFieldConstants.None || matchPoint == null) + return; + + double cachedTime = director.time; + + // finds previous clip + TimelineClip previousClip = GetPreviousClip(currentClip); + if (previousClip == null || currentClip == previousClip) + return; + + // make sure the transform is properly updated before modifying the graph + director.Evaluate(); + + var parentTrack = currentClip.parentTrack as AnimationTrack; + + var blendIn = currentClip.blendInDuration; + currentClip.blendInDuration = 0; + var blendOut = previousClip.blendOutDuration; + previousClip.blendOutDuration = 0; + + //evaluate previous without current + parentTrack.RemoveClip(currentClip); + director.RebuildGraph(); + double previousEndTime = currentClip.start > previousClip.end ? previousClip.end : currentClip.start; + director.time = previousEndTime - timeEpsilon; + director.Evaluate(); // add port to evaluate only track + + var targetPosition = matchPoint.position; + var targetRotation = matchPoint.rotation; + + // evaluate current without previous + parentTrack.AddClip(currentClip); + parentTrack.RemoveClip(previousClip); + director.RebuildGraph(); + director.time = currentClip.start + timeEpsilon; + director.Evaluate(); + + ////////////////////////////////////////////////////////////////////// + //compute offsets + + var animationPlayable = currentClip.asset as AnimationPlayableAsset; + var match = UpdateClipOffsets(animationPlayable, parentTrack, matchPoint, targetPosition, targetRotation); + WriteMatchFields(animationPlayable, match, matchFields); + + ////////////////////////////////////////////////////////////////////// + + currentClip.blendInDuration = blendIn; + previousClip.blendOutDuration = blendOut; + + parentTrack.AddClip(previousClip); + director.RebuildGraph(); + director.time = cachedTime; + director.Evaluate(); + } + + public static void MatchNext(TimelineClip currentClip, Transform matchPoint, PlayableDirector director) + { + const double timeEpsilon = 0.00001; + MatchTargetFields matchFields = GetMatchFields(currentClip); + if (matchFields == MatchTargetFieldConstants.None || matchPoint == null) + return; + + double cachedTime = director.time; + + // finds next clip + TimelineClip nextClip = GetNextClip(currentClip); + if (nextClip == null || currentClip == nextClip) + return; + + // make sure the transform is properly updated before modifying the graph + director.Evaluate(); + + var parentTrack = currentClip.parentTrack as AnimationTrack; + + var blendOut = currentClip.blendOutDuration; + var blendIn = nextClip.blendInDuration; + currentClip.blendOutDuration = 0; + nextClip.blendInDuration = 0; + + //evaluate previous without current + parentTrack.RemoveClip(currentClip); + director.RebuildGraph(); + director.time = nextClip.start + timeEpsilon; + director.Evaluate(); // add port to evaluate only track + + var targetPosition = matchPoint.position; + var targetRotation = matchPoint.rotation; + + // evaluate current without next + parentTrack.AddClip(currentClip); + parentTrack.RemoveClip(nextClip); + director.RebuildGraph(); + director.time = Math.Min(nextClip.start, currentClip.end - timeEpsilon); + director.Evaluate(); + + ////////////////////////////////////////////////////////////////////// + //compute offsets + + var animationPlayable = currentClip.asset as AnimationPlayableAsset; + var match = UpdateClipOffsets(animationPlayable, parentTrack, matchPoint, targetPosition, targetRotation); + WriteMatchFields(animationPlayable, match, matchFields); + + ////////////////////////////////////////////////////////////////////// + + currentClip.blendOutDuration = blendOut; + nextClip.blendInDuration = blendIn; + + parentTrack.AddClip(nextClip); + director.RebuildGraph(); + director.time = cachedTime; + director.Evaluate(); + } + + public static TimelineWindowTimeControl CreateTimeController(TimelineClip clip) + { + var animationWindow = EditorWindow.GetWindow(); + var timeController = ScriptableObject.CreateInstance(); + timeController.Init(animationWindow.state, clip); + return timeController; + } + + public static TimelineWindowTimeControl CreateTimeController(TimelineWindowTimeControl.ClipData clipData) + { + var animationWindow = EditorWindow.GetWindow(); + var timeController = ScriptableObject.CreateInstance(); + timeController.Init(animationWindow.state, clipData); + return timeController; + } + + public static void EditAnimationClipWithTimeController(AnimationClip animationClip, TimelineWindowTimeControl timeController, Object sourceObject) + { + var animationWindow = EditorWindow.GetWindow(); + animationWindow.EditSequencerClip(animationClip, sourceObject, timeController); + } + + public static void UnlinkAnimationWindowFromTracks(IEnumerable tracks) + { + var clips = new List(); + foreach (var track in tracks) + { + var animationTrack = track as AnimationTrack; + if (animationTrack != null && animationTrack.infiniteClip != null) + clips.Add(animationTrack.infiniteClip); + + GetAnimationClips(track.GetClips(), clips); + } + UnlinkAnimationWindowFromAnimationClips(clips); + } + + public static void UnlinkAnimationWindowFromClips(IEnumerable timelineClips) + { + var clips = new List(); + GetAnimationClips(timelineClips, clips); + UnlinkAnimationWindowFromAnimationClips(clips); + } + + public static void UnlinkAnimationWindowFromAnimationClips(ICollection clips) + { + if (clips.Count == 0) + return; + + UnityEngine.Object[] windows = Resources.FindObjectsOfTypeAll(typeof(AnimationWindow)); + foreach (var animWindow in windows.OfType()) + { + if (animWindow != null && animWindow.state != null && animWindow.state.linkedWithSequencer && clips.Contains(animWindow.state.activeAnimationClip)) + animWindow.UnlinkSequencer(); + } + } + + public static void UnlinkAnimationWindow() + { + UnityEngine.Object[] windows = Resources.FindObjectsOfTypeAll(typeof(AnimationWindow)); + foreach (var animWindow in windows.OfType()) + { + if (animWindow != null && animWindow.state != null && animWindow.state.linkedWithSequencer) + animWindow.UnlinkSequencer(); + } + } + + private static void GetAnimationClips(IEnumerable timelineClips, List clips) + { + foreach (var timelineClip in timelineClips) + { + if (timelineClip.curves != null) + clips.Add(timelineClip.curves); + AnimationPlayableAsset apa = timelineClip.asset as AnimationPlayableAsset; + if (apa != null && apa.clip != null) + clips.Add(apa.clip); + } + } + + public static int GetAnimationWindowCurrentFrame() + { + var animationWindow = EditorWindow.GetWindow(); + if (animationWindow) + return animationWindow.state.currentFrame; + return -1; + } + + public static void SetAnimationWindowCurrentFrame(int frame) + { + var animationWindow = EditorWindow.GetWindow(); + if (animationWindow) + animationWindow.state.currentFrame = frame; + } + + public static void ConstrainCurveToBooleanValues(AnimationCurve curve) + { + // Clamp the values first + var keys = curve.keys; + for (var i = 0; i < keys.Length; i++) + { + var key = keys[i]; + key.value = key.value < 0.5f ? 0.0f : 1.0f; + keys[i] = key; + } + curve.keys = keys; + + // Update the tangents once all the values are clamped + for (var i = 0; i < curve.length; i++) + { + AnimationUtility.SetKeyLeftTangentMode(curve, i, AnimationUtility.TangentMode.Constant); + AnimationUtility.SetKeyRightTangentMode(curve, i, AnimationUtility.TangentMode.Constant); + } + } + + public static void ConstrainCurveToRange(AnimationCurve curve, float minValue, float maxValue) + { + var keys = curve.keys; + for (var i = 0; i < keys.Length; i++) + { + var key = keys[i]; + key.value = Mathf.Clamp(key.value, minValue, maxValue); + keys[i] = key; + } + curve.keys = keys; + } + + public static bool IsAnimationClip(TimelineClip clip) + { + return clip != null && (clip.asset as AnimationPlayableAsset) != null; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/TimelineAnimationUtilities.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/TimelineAnimationUtilities.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..78ae589e3467bc6230a2c620e0dd94938677e97e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Animation/TimelineAnimationUtilities.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9685354eb873b8d4699078b307b0f260 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/ActiveInModeAttribute.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/ActiveInModeAttribute.cs new file mode 100644 index 0000000000000000000000000000000000000000..1b9fb8f4149a0e2635f5588c2714b45acb20b838 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/ActiveInModeAttribute.cs @@ -0,0 +1,26 @@ +using System; + +namespace UnityEditor.Timeline.Actions +{ + /// + /// Define the activeness of an action depending on its timeline mode. + /// + /// + [AttributeUsage(AttributeTargets.Class)] + public class ActiveInModeAttribute : Attribute + { + /// + /// Modes that will be used for activeness of an action. + /// + public TimelineModes modes { get; } + + /// + /// Defines in which mode the action will be active. + /// + /// Modes that will define activeness of the action. + public ActiveInModeAttribute(TimelineModes timelineModes) + { + modes = timelineModes; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/ActiveInModeAttribute.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/ActiveInModeAttribute.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..63fafba45948f0e5a07c47eef1ab3827db691449 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/ActiveInModeAttribute.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3a784fb721704576b3b4c3a7f3324264 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/MenuEntryAttribute.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/MenuEntryAttribute.cs new file mode 100644 index 0000000000000000000000000000000000000000..9433cac85ed9b8403f9eb57d30a153055a2810f2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/MenuEntryAttribute.cs @@ -0,0 +1,73 @@ +using System; +using UnityEngine; + +namespace UnityEditor.Timeline.Actions +{ + [Flags] + enum MenuFilter + { + None = 0, + Item = 1 << 0, + Track = 1 << 1, + MarkerHeader = 1 << 2, + Default = Item | Track + } + + /// + /// Use this attribute to add a menu item to a context menu. + /// Used to indicate path and priority that are auto added to the menu + /// (examples can be found on ). + /// + /// + /// + /// + /// + /// Unlike Menu item, MenuEntryAttribute doesn't handle shortcuts in the menu name. See . + /// + [AttributeUsage(AttributeTargets.Class)] + public class MenuEntryAttribute : Attribute + { + internal readonly int priority; + internal readonly string name; + internal readonly string subMenuPath; + internal readonly MenuFilter filter; + + /// + /// Constructor for Menu Entry Attribute to define information about the menu item for an action. + /// + /// Path to the menu. If there is a "/" in the path, it will create one (or multiple) submenu items. + /// Priority to decide where the menu will be positioned in the menu. + /// The lower the priority, the higher the menu item will be in the context menu. + /// + /// + public MenuEntryAttribute(string path = default, int priority = MenuPriority.defaultPriority) : this(path, priority, MenuFilter.Default) {} + + internal MenuEntryAttribute(string path, int priority, MenuFilter filter) + { + this.filter = filter; + path = path ?? string.Empty; + path = L10n.Tr(path); + this.priority = priority; + + var index = path.LastIndexOf('/'); + if (index >= 0) + { + name = (index == path.Length - 1) ? string.Empty : path.Substring(index + 1); + subMenuPath = path.Substring(0, index + 1); + } + else + { + name = path; + subMenuPath = string.Empty; + } + } + } + + static class MenuFilterExtensions + { + public static bool ShouldFilterOut(this MenuFilter filter, MenuEntryAttribute attr) + { + return (filter & attr.filter) != filter; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/MenuEntryAttribute.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/MenuEntryAttribute.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..39a11cee87d2d5248327b6274893ccad1ed12dae --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/MenuEntryAttribute.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e6870f707805737429a719f575621041 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/ShortcutAttribute.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/ShortcutAttribute.cs new file mode 100644 index 0000000000000000000000000000000000000000..756a09290ea74a9bf84ca08780bf921e7b8f30df --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/ShortcutAttribute.cs @@ -0,0 +1,71 @@ +using System; +using System.Linq; +using UnityEditor.ShortcutManagement; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + [AttributeUsage(AttributeTargets.Class, Inherited = false)] + class ShortcutAttribute : Attribute + { + readonly string m_Identifier; + readonly string m_EventCommandName; + readonly string m_MenuShortcut; + + public ShortcutAttribute(string identifier) + { + m_Identifier = identifier; + m_EventCommandName = identifier; + } + + public ShortcutAttribute(string identifier, string commandName) + { + m_Identifier = identifier; + m_EventCommandName = commandName; + } + + public ShortcutAttribute(KeyCode key, ShortcutModifiers modifiers = ShortcutModifiers.None) + { + m_MenuShortcut = new KeyCombination(key, modifiers).ToMenuShortcutString(); + } + + public string GetMenuShortcut() + { + if (m_MenuShortcut != null) + return m_MenuShortcut; + + //find the mapped shortcut in the shortcut manager + var shortcut = ShortcutIntegration.instance.directory.FindShortcutEntry(m_Identifier); + if (shortcut != null && shortcut.combinations.Any()) + { + return KeyCombination.SequenceToMenuString(shortcut.combinations); + } + + return string.Empty; + } + + public bool MatchesEvent(Event evt) + { + if (evt.type != EventType.ExecuteCommand) + return false; + return evt.commandName == m_EventCommandName; + } + } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)] + class ShortcutPlatformOverrideAttribute : ShortcutAttribute + { + RuntimePlatform platform { get; } + + public ShortcutPlatformOverrideAttribute(RuntimePlatform platform, KeyCode key, ShortcutModifiers modifiers = ShortcutModifiers.None) + : base(key, modifiers) + { + this.platform = platform; + } + + public bool MatchesCurrentPlatform() + { + return Application.platform == platform; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/ShortcutAttribute.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/ShortcutAttribute.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2d02db95da8c4d004c07f8bab9302d875dd998c0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/ShortcutAttribute.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c50a694a8232898498c1cdd47ce9873f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/TimelineShortcutAttribute.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/TimelineShortcutAttribute.cs new file mode 100644 index 0000000000000000000000000000000000000000..2676f93d649cd25153cf7d3279e795f2e3dbcd98 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/TimelineShortcutAttribute.cs @@ -0,0 +1,24 @@ +using UnityEditor.ShortcutManagement; +using UnityEngine; + +namespace UnityEditor.Timeline.Actions +{ + /// + /// Use this attribute to make an action work with the shortcut system. + /// + /// + /// TimelineShortcutAttribute needs to be added to a static method. + /// + /// + public class TimelineShortcutAttribute : ShortcutManagement.ShortcutAttribute + { + /// + /// TimelineShortcutAttribute Constructor + /// + /// Id to register the shortcut. It will automatically be prefix by 'Timeline/' in order to be in the 'Timeline' section of the shortcut manager. + /// Optional key code for default binding. + /// Optional shortcut modifiers for default binding. + public TimelineShortcutAttribute(string id, KeyCode defaultKeyCode, ShortcutModifiers defaultShortcutModifiers = ShortcutModifiers.None) + : base("Timeline/" + id, typeof(TimelineWindow), defaultKeyCode, defaultShortcutModifiers) {} + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/TimelineShortcutAttribute.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/TimelineShortcutAttribute.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..77d22ee12d34ada7a4b8cace9de4fc4d7acd9561 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Attributes/TimelineShortcutAttribute.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bbfc068399dbc814d96ebf991a1e5764 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioClipPropertiesDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioClipPropertiesDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..e3ec1326eca118c7f39418fae61956fd00384862 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioClipPropertiesDrawer.cs @@ -0,0 +1,81 @@ +using System; +using System.Globalization; +using System.Linq; +using System.Text; +using JetBrains.Annotations; +using UnityEditor; +using UnityEditor.Timeline; + +namespace UnityEngine.Timeline +{ + [CustomPropertyDrawer(typeof(AudioClipProperties))] + class AudioClipPropertiesDrawer : PropertyDrawer + { + [UsedImplicitly] // Also used by tests + internal static class Styles + { + public const string VolumeControl = "AudioClipPropertiesDrawer.volume"; + + const string k_Indent = " "; + public const string valuesFormatter = "0.###"; + public static string mixedPropertiesInfo = L10n.Tr("The final {3} is {0}\n" + + "Calculated from:\n" + + k_Indent + "Clip: {1}\n" + + k_Indent + "Track: {2}"); + + public static string audioSourceContribution = L10n.Tr(k_Indent + "AudioSource: {0}"); + } + + static StringBuilder s_MixInfoBuilder = new StringBuilder(); + + public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) + { + var volumeProp = property.FindPropertyRelative("volume"); + + GUI.SetNextControlName(Styles.VolumeControl); + EditorGUI.Slider(position, volumeProp, 0.0f, 1.0f, AudioSourceInspector.Styles.volumeLabel); + + if (TimelineEditor.inspectedDirector == null) + // Nothing more to do in asset mode + return; + + var clip = SelectionManager.SelectedClips().FirstOrDefault(c => c.asset == property.serializedObject.targetObject); + + if (clip == null || clip.parentTrack == null) + return; + + var clipVolume = volumeProp.floatValue; + var trackVolume = new SerializedObject(clip.parentTrack).FindProperty("m_TrackProperties.volume").floatValue; + var binding = TimelineEditor.inspectedDirector.GetGenericBinding(clip.parentTrack) as AudioSource; + + if (Math.Abs(clipVolume) < float.Epsilon && + Math.Abs(trackVolume) < float.Epsilon && + (binding == null || Math.Abs(binding.volume) < float.Epsilon)) + return; + + if (Math.Abs(clipVolume - 1) < float.Epsilon && + Math.Abs(trackVolume - 1) < float.Epsilon && + (binding == null || Math.Abs(binding.volume - 1) < float.Epsilon)) + return; + + s_MixInfoBuilder.Length = 0; + + var audioSourceVolume = binding == null ? 1.0f : binding.volume; + + s_MixInfoBuilder.AppendFormat( + Styles.mixedPropertiesInfo, + (clipVolume * trackVolume * audioSourceVolume).ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture), + clipVolume.ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture), + trackVolume.ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture), + AudioSourceInspector.Styles.volumeLabel.text); + + if (binding != null) + s_MixInfoBuilder.Append("\n") + .AppendFormat(Styles.audioSourceContribution, + audioSourceVolume.ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture)); + + EditorGUILayout.Space(); + EditorGUILayout.HelpBox(new GUIContent(s_MixInfoBuilder.ToString())); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioClipPropertiesDrawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioClipPropertiesDrawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..60501c3b1809d493ee87cc08b047b2173a3aeeb2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioClipPropertiesDrawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5b6cac4a98010394791c66942a33caf4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioPlayableAssetEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioPlayableAssetEditor.cs new file mode 100644 index 0000000000000000000000000000000000000000..9c8d999bc6b7f32e50550dc1e1c68d9ad4b5d075 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioPlayableAssetEditor.cs @@ -0,0 +1,104 @@ +using System.Collections.Generic; +using JetBrains.Annotations; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [CustomTimelineEditor(typeof(AudioPlayableAsset)), UsedImplicitly] + class AudioPlayableAssetEditor : ClipEditor + { + readonly string k_NoClipAssignedError = L10n.Tr("No audio clip assigned"); + readonly Dictionary m_PersistentPreviews = new Dictionary(); + ColorSpace m_ColorSpace = ColorSpace.Uninitialized; + + public override ClipDrawOptions GetClipOptions(TimelineClip clip) + { + var clipOptions = base.GetClipOptions(clip); + var audioAsset = clip.asset as AudioPlayableAsset; + if (audioAsset != null && audioAsset.clip == null) + clipOptions.errorText = k_NoClipAssignedError; + return clipOptions; + } + + public override void DrawBackground(TimelineClip clip, ClipBackgroundRegion region) + { + if (!TimelineWindow.instance.state.showAudioWaveform) + return; + + var rect = region.position; + if (rect.width <= 0) + return; + + var audioClip = clip.asset as AudioClip; + if (audioClip == null) + { + var audioPlayableAsset = clip.asset as AudioPlayableAsset; + if (audioPlayableAsset != null) + audioClip = audioPlayableAsset.clip; + } + + if (audioClip == null) + return; + + var quantizedRect = new Rect(Mathf.Ceil(rect.x), Mathf.Ceil(rect.y), Mathf.Ceil(rect.width), Mathf.Ceil(rect.height)); + + WaveformPreview preview = GetOrCreateWaveformPreview(clip, audioClip, quantizedRect, region.startTime, region.endTime); + if (Event.current.type == EventType.Repaint) + DrawWaveformPreview(preview, quantizedRect); + } + + public WaveformPreview GetOrCreateWaveformPreview(TimelineClip clip, AudioClip audioClip, Rect rect, double startTime, double endTime) + { + if (QualitySettings.activeColorSpace != m_ColorSpace) + { + m_ColorSpace = QualitySettings.activeColorSpace; + m_PersistentPreviews.Clear(); + } + + bool previewExists = m_PersistentPreviews.TryGetValue(clip, out WaveformPreview preview); + bool audioClipHasChanged = preview != null && audioClip != preview.presentedObject; + if (!previewExists || audioClipHasChanged) + { + if (AssetDatabase.Contains(audioClip)) + preview = CreateWaveformPreview(audioClip, rect); + m_PersistentPreviews[clip] = preview; + } + + if (preview == null) + return null; + + preview.looping = clip.SupportsLooping(); + preview.SetTimeInfo(startTime, endTime - startTime); + preview.OptimizeForSize(rect.size); + return preview; + } + + public static void DrawWaveformPreview(WaveformPreview preview, Rect rect) + { + if (preview != null) + { + preview.ApplyModifications(); + preview.Render(rect); + } + } + + static WaveformPreview CreateWaveformPreview(AudioClip audioClip, Rect quantizedRect) + { + WaveformPreview preview = WaveformPreviewFactory.Create((int)quantizedRect.width, audioClip); + Color waveColour = GammaCorrect(DirectorStyles.Instance.customSkin.colorAudioWaveform); + Color transparent = waveColour; + transparent.a = 0; + preview.backgroundColor = transparent; + preview.waveColor = waveColour; + preview.SetChannelMode(WaveformPreview.ChannelMode.MonoSum); + preview.updated += () => TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw); + return preview; + } + + static Color GammaCorrect(Color color) + { + return (QualitySettings.activeColorSpace == ColorSpace.Linear) ? color.gamma : color; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioPlayableAssetEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioPlayableAssetEditor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e9bee5aefacd44e71899579dd334454eb4fee83d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioPlayableAssetEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 74374298effb78d47b85450f7f724cef +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioPlayableAssetInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioPlayableAssetInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..31897fcd7c1228f86aab46dfb92d7ea091f0d1e1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioPlayableAssetInspector.cs @@ -0,0 +1,27 @@ +using UnityEditor; +using UnityEditor.Timeline; +using UnityEngine.Playables; + +namespace UnityEngine.Timeline +{ + [CustomEditor(typeof(AudioPlayableAsset))] + class AudioPlayableAssetInspector : BasicAssetInspector + { + public override void ApplyChanges() + { + // At this point, we are guaranteed that the Timeline window is focused on + // the correct asset and that a single clip is selected (see ClipInspector) + + if (TimelineEditor.inspectedDirector == null) + // Do nothing if in asset mode + return; + + var asset = (AudioPlayableAsset)target; + + if (TimelineEditor.inspectedDirector.state == PlayState.Playing) + asset.LiveLink(); + else + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioPlayableAssetInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioPlayableAssetInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..b768ab94e5acacbc5e5a51d8f9ee78e93564958e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioPlayableAssetInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 23884ce4c1de32846adafea2d53a4cee +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioTrackInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioTrackInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..0c1a110ecaf9f1648ca634bc13cafc46f2ba86a0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioTrackInspector.cs @@ -0,0 +1,164 @@ +using System; +using System.Globalization; +using System.Linq; +using System.Text; +using JetBrains.Annotations; +using UnityEditor; +using UnityEditor.Timeline; +using UnityEngine.Playables; + +namespace UnityEngine.Timeline +{ + [CustomEditor(typeof(AudioTrack))] + [CanEditMultipleObjects] + class AudioTrackInspector : TrackAssetInspector + { + [UsedImplicitly] // Also used by tests + internal static class Styles + { + public const string VolumeControl = "AudioTrackInspector.volume"; + public const string StereoPanControl = "AudioTrackInspector.stereoPan"; + public const string SpatialBlendControl = "AudioTrackInspector.spatialBlend"; + + const string k_Indent = " "; + public const string valuesFormatter = "0.###"; + public const string mixInfoSectionSeparator = "\n\n"; + public static string mixedPropertiesInfo = L10n.Tr("The final {3} is {0}\n" + + "Calculated from:\n" + + k_Indent + "Track: {1}\n" + + k_Indent + "AudioSource: {2}"); + } + + static StringBuilder s_MixInfoBuilder = new StringBuilder(); + + SerializedProperty m_VolumeProperty; + SerializedProperty m_StereoPanProperty; + SerializedProperty m_SpatialBlendProperty; + PlayableDirector m_Director; + + public override void OnEnable() + { + base.OnEnable(); + + if (((AudioTrack)target).timelineAsset == TimelineEditor.inspectedAsset) + m_Director = TimelineEditor.inspectedDirector; + + m_VolumeProperty = serializedObject.FindProperty("m_TrackProperties.volume"); + m_StereoPanProperty = serializedObject.FindProperty("m_TrackProperties.stereoPan"); + m_SpatialBlendProperty = serializedObject.FindProperty("m_TrackProperties.spatialBlend"); + } + + protected override void DrawTrackProperties() + { + // Volume + GUI.SetNextControlName(Styles.VolumeControl); + EditorGUILayout.Slider(m_VolumeProperty, 0.0f, 1.0f, AudioSourceInspector.Styles.volumeLabel); + EditorGUILayout.Space(); + + // Stereo Pan + GUI.SetNextControlName(Styles.StereoPanControl); + EditorGUIUtility.sliderLabels.SetLabels(AudioSourceInspector.Styles.panLeftLabel, AudioSourceInspector.Styles.panRightLabel); + EditorGUILayout.Slider(m_StereoPanProperty, -1.0f, 1.0f, AudioSourceInspector.Styles.panStereoLabel); + EditorGUIUtility.sliderLabels.SetLabels(null, null); + EditorGUILayout.Space(); + + // Spatial Blend + using (new EditorGUI.DisabledScope(ShouldDisableSpatialBlend())) + { + GUI.SetNextControlName(Styles.SpatialBlendControl); + EditorGUIUtility.sliderLabels.SetLabels(AudioSourceInspector.Styles.spatialLeftLabel, AudioSourceInspector.Styles.spatialRightLabel); + EditorGUILayout.Slider(m_SpatialBlendProperty, 0.0f, 1.0f, AudioSourceInspector.Styles.spatialBlendLabel); + EditorGUIUtility.sliderLabels.SetLabels(null, null); + } + + DrawMixInfoSection(); + } + + void DrawMixInfoSection() + { + if (m_Director == null || targets.Length > 1) + return; + + var binding = m_Director.GetGenericBinding(target) as AudioSource; + if (binding == null) + return; + + var audioSourceVolume = binding.volume; + var audioSourcePan = binding.panStereo; + var audioSourceBlend = binding.spatialBlend; + + var trackVolume = m_VolumeProperty.floatValue; + var trackPan = m_StereoPanProperty.floatValue; + var trackBlend = m_SpatialBlendProperty.floatValue; + + // Skip sections when result is obvious + + var skipVolumeInfo = Math.Abs(audioSourceVolume) < float.Epsilon && Math.Abs(trackVolume) < float.Epsilon || // All muted + Math.Abs(audioSourceVolume - 1) < float.Epsilon && Math.Abs(trackVolume - 1) < float.Epsilon; // All max volume + + var skipPanInfo = Math.Abs(audioSourcePan) < float.Epsilon && Math.Abs(trackPan) < float.Epsilon || // All centered + Math.Abs(audioSourcePan - 1) < float.Epsilon && Math.Abs(trackPan - 1) < float.Epsilon || // All right + Math.Abs(audioSourcePan - (-1.0f)) < float.Epsilon && Math.Abs(trackPan - (-1.0f)) < float.Epsilon; // All left + + var skipBlendInfo = Math.Abs(audioSourceBlend) < float.Epsilon && Math.Abs(trackBlend) < float.Epsilon || // All 2D + Math.Abs(audioSourceBlend - 1) < float.Epsilon && Math.Abs(trackBlend - 1) < float.Epsilon; // All 3D + + if (skipVolumeInfo && skipPanInfo && skipBlendInfo) + return; + + s_MixInfoBuilder.Length = 0; + + if (!skipVolumeInfo) + s_MixInfoBuilder.AppendFormat( + Styles.mixedPropertiesInfo, + (audioSourceVolume * trackVolume).ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture), + trackVolume.ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture), + audioSourceVolume.ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture), + AudioSourceInspector.Styles.volumeLabel.text); + + if (!skipVolumeInfo && !skipPanInfo) + s_MixInfoBuilder.Append(Styles.mixInfoSectionSeparator); + + if (!skipPanInfo) + s_MixInfoBuilder.AppendFormat( + Styles.mixedPropertiesInfo, + Mathf.Clamp(audioSourcePan + trackPan, -1.0f, 1.0f).ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture), + trackPan.ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture), + audioSourcePan.ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture), + AudioSourceInspector.Styles.panStereoLabel.text); + + if ((!skipVolumeInfo || !skipPanInfo) && !skipBlendInfo) + s_MixInfoBuilder.Append(Styles.mixInfoSectionSeparator); + + if (!skipBlendInfo) + s_MixInfoBuilder.AppendFormat( + Styles.mixedPropertiesInfo, + Mathf.Clamp01(audioSourceBlend + trackBlend).ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture), + trackBlend.ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture), + audioSourceBlend.ToString(Styles.valuesFormatter, CultureInfo.InvariantCulture), + AudioSourceInspector.Styles.spatialBlendLabel.text); + + EditorGUILayout.Space(); + EditorGUILayout.HelpBox(new GUIContent(s_MixInfoBuilder.ToString())); + } + + protected override void ApplyChanges() + { + var track = (AudioTrack)target; + + if (TimelineEditor.inspectedAsset != track.timelineAsset || TimelineEditor.inspectedDirector == null) + return; + + if (TimelineEditor.inspectedDirector.state == PlayState.Playing) + track.LiveLink(); + else + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + bool ShouldDisableSpatialBlend() + { + return m_Director == null || + targets.Any(selectedTrack => m_Director.GetGenericBinding(selectedTrack) == null); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioTrackInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioTrackInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..4d4bc763d3333d865c9609b92afaa5ee73a06130 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Audio/AudioTrackInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 57acdaad593b8d143b8fb5052a09d7d0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/ControlTrack/ControlPlayableAssetEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/ControlTrack/ControlPlayableAssetEditor.cs new file mode 100644 index 0000000000000000000000000000000000000000..066e943d89b6b8b1304de557f3190400353a634c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/ControlTrack/ControlPlayableAssetEditor.cs @@ -0,0 +1,69 @@ +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + [CustomTimelineEditor(typeof(ControlPlayableAsset))] + class ControlPlayableAssetEditor : ClipEditor + { + static readonly Texture2D[] s_ParticleSystemIcon = {AssetPreview.GetMiniTypeThumbnail(typeof(ParticleSystem))}; + + public override ClipDrawOptions GetClipOptions(TimelineClip clip) + { + var asset = (ControlPlayableAsset)clip.asset; + var options = base.GetClipOptions(clip); + if (asset.updateParticle && TimelineEditor.inspectedDirector != null && asset.controllingParticles) + options.icons = s_ParticleSystemIcon; + return options; + } + + public override void OnCreate(TimelineClip clip, TrackAsset track, TimelineClip clonedFrom) + { + var asset = (ControlPlayableAsset)clip.asset; + GameObject sourceObject = null; + + // go by sourceObject first, then by prefab + if (TimelineEditor.inspectedDirector != null) + sourceObject = asset.sourceGameObject.Resolve(TimelineEditor.inspectedDirector); + + if (sourceObject == null && asset.prefabGameObject != null) + sourceObject = asset.prefabGameObject; + + if (sourceObject) + { + var directors = asset.GetComponent(sourceObject); + var particleSystems = asset.GetComponent(sourceObject); + + // update the duration and loop values (used for UI purposes) here + // so they are tied to the latest gameObject bound + asset.UpdateDurationAndLoopFlag(directors, particleSystems); + + clip.displayName = sourceObject.name; + } + } + + public override void GetSubTimelines(TimelineClip clip, PlayableDirector director, List subTimelines) + { + var asset = (ControlPlayableAsset)clip.asset; + + // If there is a prefab, it will override the source GameObject + if (!asset.updateDirector || asset.prefabGameObject != null || director == null) + return; + + var go = asset.sourceGameObject.Resolve(director); + if (go == null) + return; + + foreach (var subTimeline in asset.GetComponent(go)) + { + if (subTimeline == director || subTimeline == TimelineEditor.masterDirector || subTimeline == TimelineEditor.inspectedDirector) + continue; + + if (subTimeline.playableAsset is TimelineAsset) + subTimelines.Add(subTimeline); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/ControlTrack/ControlPlayableAssetEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/ControlTrack/ControlPlayableAssetEditor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..ece3e1f475e4cf81e090ef47cc250a9d8c821ab1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/ControlTrack/ControlPlayableAssetEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b5489bb3cd68836439785588fffc67a4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/ClipEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/ClipEditor.cs new file mode 100644 index 0000000000000000000000000000000000000000..b6d9a46167640d6963061db9c1d8b7041b2cfd98 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/ClipEditor.cs @@ -0,0 +1,307 @@ +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + /// + /// Description of the on-screen area where a clip is drawn + /// + public struct ClipBackgroundRegion + { + /// + /// The rectangle where the background of the clip is drawn. + /// + /// + /// The rectangle is clipped to the screen. The rectangle does not include clip borders. + /// + public Rect position { get; private set; } + + /// + /// The start time of the region, relative to the clip. + /// + public double startTime { get; private set; } + + /// + /// The end time of the region, relative to the clip. + /// + public double endTime { get; private set; } + + /// + /// Constructor + /// + /// + /// + /// + public ClipBackgroundRegion(Rect _position, double _startTime, double _endTime) + { + position = _position; + startTime = _startTime; + endTime = _endTime; + } + + /// + /// Indicates whether this instance and a specified object are equal. + /// + /// The object to compare with the current instance. + /// Returns true if and this instance are the same type and represent the same value. + public override bool Equals(object obj) + { + if (!(obj is ClipBackgroundRegion)) + return false; + + return Equals((ClipBackgroundRegion)obj); + } + + /// + /// Compares this object with another ClipBackgroundRegion. + /// + /// The object to compare with. + /// Returns true if this and are equal. + public bool Equals(ClipBackgroundRegion other) + { + return position.Equals(other.position) && + startTime == other.startTime && + endTime == other.endTime; + } + + /// + /// Returns the hash code for this instance. + /// + /// A 32-bit signed integer that is the hash code for this instance. + public override int GetHashCode() + { + return HashUtility.CombineHash( + position.GetHashCode(), + startTime.GetHashCode(), + endTime.GetHashCode() + ); + } + + /// + /// Compares two ClipBackgroundRegion objects. + /// + /// The first object. + /// The second object. + /// Returns true if they are equal. + public static bool operator==(ClipBackgroundRegion region1, ClipBackgroundRegion region2) + { + return region1.Equals(region2); + } + + /// + /// Compares two ClipBackgroundRegion objects. + /// + /// The first object. + /// The second object. + /// Returns true if they are not equal. + public static bool operator!=(ClipBackgroundRegion region1, ClipBackgroundRegion region2) + { + return !region1.Equals(region2); + } + } + + /// + /// The user-defined options for drawing a clip. + /// + public struct ClipDrawOptions + { + private IEnumerable m_Icons; + + /// + /// Text that indicates if the clip should display an error. + /// + /// + /// If the error text is not empty or null, then the clip displays a warning. The error text is used as the tooltip. + /// + public string errorText { get; set; } + + /// + /// The tooltip to show for the clip. + /// + public string tooltip { get; set; } + + /// + /// The color drawn under the clip. By default, the color is the same as the track color. + /// + public Color highlightColor { get; set; } + + + /// + /// Icons to display on the clip. + /// + public IEnumerable icons + { + get { return m_Icons ?? System.Linq.Enumerable.Empty(); } + set { m_Icons = value;} + } + + /// + /// Indicates whether this instance and a specified object are equal. + /// + /// The object to compare with the current instance. + /// Returns true if and this instance are the same type and represent the same value. + public override bool Equals(object obj) + { + if (!(obj is ClipDrawOptions)) + return false; + + return Equals((ClipDrawOptions)obj); + } + + /// + /// Compares this object with another ClipDrawOptions. + /// + /// The object to compare with. + /// Returns true if this and are equal. + public bool Equals(ClipDrawOptions other) + { + return errorText == other.errorText && + tooltip == other.tooltip && + highlightColor == other.highlightColor && + System.Linq.Enumerable.SequenceEqual(icons, other.icons); + } + + /// + /// Returns the hash code for this instance. + /// + /// A 32-bit signed integer that is the hash code for this instance. + public override int GetHashCode() + { + return HashUtility.CombineHash( + errorText != null ? errorText.GetHashCode() : 0, + tooltip != null ? tooltip.GetHashCode() : 0, + highlightColor.GetHashCode(), + icons != null ? icons.GetHashCode() : 0 + ); + } + + /// + /// Compares two ClipDrawOptions objects. + /// + /// The first object. + /// The second object. + /// Returns true if they are equal. + public static bool operator==(ClipDrawOptions options1, ClipDrawOptions options2) + { + return options1.Equals(options2); + } + + /// + /// Compares two ClipDrawOptions objects. + /// + /// The first object. + /// The second object. + /// Returns true if they are not equal. + public static bool operator!=(ClipDrawOptions options1, ClipDrawOptions options2) + { + return !options1.Equals(options2); + } + } + + /// + /// Use this class to customize clip types in the TimelineEditor. + /// + public class ClipEditor + { + static readonly string k_NoPlayableAssetError = L10n.Tr("This clip does not contain a valid playable asset"); + static readonly string k_ScriptLoadError = L10n.Tr("The associated script can not be loaded"); + + internal readonly bool supportsSubTimelines; + + /// + /// Default constructor + /// + public ClipEditor() + { + supportsSubTimelines = TypeUtility.HasOverrideMethod(GetType(), nameof(GetSubTimelines)); + } + + /// + /// Implement this method to override the default options for drawing a clip. + /// + /// The clip being drawn. + /// The options for drawing a clip. + public virtual ClipDrawOptions GetClipOptions(TimelineClip clip) + { + return new ClipDrawOptions() + { + errorText = GetErrorText(clip), + tooltip = string.Empty, + highlightColor = GetDefaultHighlightColor(clip), + icons = System.Linq.Enumerable.Empty() + }; + } + + /// + /// Override this method to draw a background for a clip . + /// + /// The clip being drawn. + /// The on-screen area where the clip is drawn. + public virtual void DrawBackground(TimelineClip clip, ClipBackgroundRegion region) + { + } + + /// + /// Called when a clip is created. + /// + /// The newly created clip. + /// The track that the clip is assigned to. + /// The source that the clip was copied from. This can be set to null if the clip is not a copy. + /// + /// The callback occurs before the clip is assigned to the track. + /// + public virtual void OnCreate(TimelineClip clip, TrackAsset track, TimelineClip clonedFrom) + { + } + + /// + /// Gets the error text for the specified clip. + /// + /// The clip being drawn. + /// Returns the error text to be displayed as the tool tip for the clip. If there is no error to be displayed, this method returns string.Empty. + public string GetErrorText(TimelineClip clip) + { + if (clip == null || clip.asset == null) + return k_NoPlayableAssetError; + + var playableAsset = clip.asset as ScriptableObject; + if (playableAsset == null || MonoScript.FromScriptableObject(playableAsset) == null) + return k_ScriptLoadError; + + return string.Empty; + } + + /// + /// The color drawn under the clip. By default, the color is the same as the track color. + /// + /// The clip being drawn. + /// Returns the highlight color of the clip being drawn. + public Color GetDefaultHighlightColor(TimelineClip clip) + { + if (clip == null) + return Color.white; + + return TrackResourceCache.GetTrackColor(clip.parentTrack); + } + + /// + /// Called when a clip is changed by the Editor. + /// + /// The clip that changed. + public virtual void OnClipChanged(TimelineClip clip) + { + } + + /// + /// Gets the sub-timelines for a specific clip. Implement this method if your clip supports playing nested timelines. + /// + /// The clip with the ControlPlayableAsset. + /// The playable director driving the Timeline Clip. This may not be the same as TimelineEditor.inspectedDirector. + /// Specify the sub-timelines to control. + public virtual void GetSubTimelines(TimelineClip clip, PlayableDirector director, List subTimelines) + { + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/ClipEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/ClipEditor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..da1b7b5d8b49dbb87fcd2f51290aa94fbbb2f88c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/ClipEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2537ddddebaa455409dec422eb08fd7e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/CustomTimelineEditorCache.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/CustomTimelineEditorCache.cs new file mode 100644 index 0000000000000000000000000000000000000000..8211a9851b7036e41909e1c136cd2917526f639a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/CustomTimelineEditorCache.cs @@ -0,0 +1,155 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class CustomTimelineEditorCache + { + static class SubClassCache where TEditorClass : class, new() + { + private static Type[] s_SubClasses = null; + private static readonly TEditorClass s_DefaultInstance = new TEditorClass(); + private static readonly Dictionary s_TypeMap = new Dictionary(); + + public static TEditorClass DefaultInstance + { + get { return s_DefaultInstance; } + } + + static Type[] SubClasses + { + get + { + // order the subclass array by built-ins then user defined so built-in classes are chosen first + return s_SubClasses ?? + (s_SubClasses = TypeCache.GetTypesDerivedFrom().OrderBy(t => t.Assembly == typeof(UnityEditor.Timeline.TimelineEditor).Assembly ? 1 : 0).ToArray()); + } + } + + public static TEditorClass GetEditorForType(Type type) + { + TEditorClass editorClass = null; + if (!s_TypeMap.TryGetValue(type, out editorClass) || editorClass == null) + { + Type editorClassType = null; + Type searchType = type; + while (searchType != null) + { + // search our way up the runtime class hierarchy so we get the best match + editorClassType = GetExactEditorClassForType(searchType); + if (editorClassType != null) + break; + searchType = searchType.BaseType; + } + + if (editorClassType == null) + { + editorClass = s_DefaultInstance; + } + else + { + try + { + editorClass = (TEditorClass)Activator.CreateInstance(editorClassType); + } + catch (Exception e) + { + Debug.LogWarningFormat("Could not create a Timeline editor class of type {0}: {1}", editorClassType, e.Message); + editorClass = s_DefaultInstance; + } + } + + s_TypeMap[type] = editorClass; + } + + return editorClass; + } + + private static Type GetExactEditorClassForType(Type type) + { + foreach (var subClass in SubClasses) + { + // first check for exact match + var attr = (CustomTimelineEditorAttribute)Attribute.GetCustomAttribute(subClass, typeof(CustomTimelineEditorAttribute), false); + if (attr != null && attr.classToEdit == type) + { + return subClass; + } + } + + return null; + } + + public static void Clear() + { + s_TypeMap.Clear(); + s_SubClasses = null; + } + } + + public static TEditorClass GetEditorForType(Type type) where TEditorClass : class, new() + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + + if (!typeof(TRuntimeClass).IsAssignableFrom(type)) + throw new ArgumentException(type.FullName + " does not inherit from" + typeof(TRuntimeClass)); + + return SubClassCache.GetEditorForType(type); + } + + public static void ClearCache() where TEditorClass : class, new() + { + SubClassCache.Clear(); + } + + public static ClipEditor GetClipEditor(TimelineClip clip) + { + if (clip == null) + throw new ArgumentNullException(nameof(clip)); + + var type = typeof(IPlayableAsset); + if (clip.asset != null) + type = clip.asset.GetType(); + + if (!typeof(IPlayableAsset).IsAssignableFrom(type)) + return GetDefaultClipEditor(); + + return GetEditorForType(type); + } + + public static ClipEditor GetDefaultClipEditor() + { + return SubClassCache.DefaultInstance; + } + + public static TrackEditor GetTrackEditor(TrackAsset track) + { + if (track == null) + throw new ArgumentNullException(nameof(track)); + + return GetEditorForType(track.GetType()); + } + + public static TrackEditor GetDefaultTrackEditor() + { + return SubClassCache.DefaultInstance; + } + + public static MarkerEditor GetMarkerEditor(IMarker marker) + { + if (marker == null) + throw new ArgumentNullException(nameof(marker)); + return GetEditorForType(marker.GetType()); + } + + public static MarkerEditor GetDefaultMarkerEditor() + { + return SubClassCache.DefaultInstance; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/CustomTimelineEditorCache.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/CustomTimelineEditorCache.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..03cae8e245994f7109d67157040cb7d8c8d2a712 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/CustomTimelineEditorCache.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fd6ede1d2f47ab146b2ec0a3969a37cc +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/MarkerEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/MarkerEditor.cs new file mode 100644 index 0000000000000000000000000000000000000000..9c678c14747270f6688ef090fb7e74752fd12f0b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/MarkerEditor.cs @@ -0,0 +1,263 @@ +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + /// + /// The flags that indicate the view status of a marker. + /// + [System.Flags] + public enum MarkerUIStates + { + /// + /// No extra state specified. + /// + None = 0, + + /// + /// The marker is selected. + /// + Selected = 1 << 0, + + /// + /// The marker is in a collapsed state. + /// + Collapsed = 1 << 1 + } + + /// + /// The user-defined options for drawing a marker. + /// + public struct MarkerDrawOptions + { + /// + /// The tooltip for the marker. + /// + public string tooltip { get; set; } + + /// + /// Text that indicates if the marker should display an error. + /// + /// + /// If the error text is not empty or null, then the marker displays a warning. The error text is used as the tooltip. + /// + public string errorText { get; set; } + + /// + /// Indicates whether this instance and a specified object are equal. + /// + /// The object to compare with the current instance. + /// Returns true if and this instance are the same type and represent the same value. + public override bool Equals(object obj) + { + if (!(obj is MarkerDrawOptions)) + return false; + + return Equals((MarkerDrawOptions)obj); + } + + /// + /// Compares this object with another MarkerDrawOptions. + /// + /// The object to compare with. + /// Returns true if this and are equal. + public bool Equals(MarkerDrawOptions other) + { + return errorText == other.errorText && + tooltip == other.tooltip; + } + + /// + /// Returns the hash code for this instance. + /// + /// A 32-bit signed integer that is the hash code for this instance. + public override int GetHashCode() + { + return HashUtility.CombineHash( + errorText != null ? errorText.GetHashCode() : 0, + tooltip != null ? tooltip.GetHashCode() : 0 + ); + } + + /// + /// Compares two MarkerDrawOptions objects. + /// + /// The first object. + /// The second object. + /// Returns true if they are equal. + public static bool operator==(MarkerDrawOptions options1, MarkerDrawOptions options2) + { + return options1.Equals(options2); + } + + /// + /// Compares two MarkerDrawOptions objects. + /// + /// The first object. + /// The second object. + /// Returns true if they are not equal. + public static bool operator!=(MarkerDrawOptions options1, MarkerDrawOptions options2) + { + return !options1.Equals(options2); + } + } + + + /// + /// The description of the on-screen area where the marker is drawn. + /// + public struct MarkerOverlayRegion + { + /// + /// The area where the marker is being drawn. + /// + public Rect markerRegion { get; private set; } + + /// + /// TThe area where the overlay is being drawn. + /// + public Rect timelineRegion { get; private set; } + + /// + /// The start time of the visible region of the window. + /// + public double startTime { get; private set; } + + /// + /// The end time of the visible region of the window. + /// + public double endTime { get; private set; } + + /// Constructor + /// + /// + /// + /// + public MarkerOverlayRegion(Rect _markerRegion, Rect _timelineRegion, double _startTime, double _endTime) + { + markerRegion = _markerRegion; + timelineRegion = _timelineRegion; + startTime = _startTime; + endTime = _endTime; + } + + /// + /// Indicates whether this instance and a specified object are equal. + /// + /// The object to compare with the current instance. + /// Returns true if and this instance are the same type and represent the same value. + public override bool Equals(object obj) + { + if (!(obj is MarkerOverlayRegion)) + return false; + + return Equals((MarkerOverlayRegion)obj); + } + + /// + /// Compares this object with another MarkerOverlayRegion. + /// + /// The object to compare with. + /// Returns true if this and are equal. + public bool Equals(MarkerOverlayRegion other) + { + return markerRegion == other.markerRegion && + timelineRegion == other.timelineRegion && + startTime == other.startTime && + endTime == other.endTime; + } + + /// + /// Returns the hash code for this instance. + /// + /// A 32-bit signed integer that is the hash code for this instance. + public override int GetHashCode() + { + return HashUtility.CombineHash( + markerRegion.GetHashCode(), + timelineRegion.GetHashCode(), + startTime.GetHashCode(), + endTime.GetHashCode() + ); + } + + /// + /// Compares two MarkerOverlayRegion objects. + /// + /// The first object. + /// The second object. + /// Returns true if they are equal. + public static bool operator==(MarkerOverlayRegion region1, MarkerOverlayRegion region2) + { + return region1.Equals(region2); + } + + /// + /// Compares two MarkerOverlayRegion objects. + /// + /// The first object. + /// The second object. + /// Returns true if they are not equal. + public static bool operator!=(MarkerOverlayRegion region1, MarkerOverlayRegion region2) + { + return !region1.Equals(region2); + } + } + + /// + /// Use this class to customize marker types in the TimelineEditor. + /// + public class MarkerEditor + { + internal readonly bool supportsDrawOverlay; + + /// + /// Default constructor + /// + public MarkerEditor() + { + supportsDrawOverlay = TypeUtility.HasOverrideMethod(GetType(), nameof(DrawOverlay)); + } + + /// + /// Implement this method to override the default options for drawing a marker. + /// + /// The marker to draw. + /// + public virtual MarkerDrawOptions GetMarkerOptions(IMarker marker) + { + return new MarkerDrawOptions() + { + tooltip = string.Empty, + errorText = string.Empty, + }; + } + + /// + /// Called when a marker is created. + /// + /// The marker that is created. + /// TThe source that the marker was copied from. This can be set to null if the marker is not a copy. + /// + /// The callback occurs before the marker is assigned to the track. + /// + public virtual void OnCreate(IMarker marker, IMarker clonedFrom) + { + } + + /// + /// Draws additional overlays for a marker. + /// + /// The marker to draw. + /// The visual state of the marker. + /// The on-screen area where the marker is being drawn. + /// + /// Notes: + /// * It is only called during TimelineWindow's Repaint step. + /// * If there are multiple markers on top of each other, only the topmost marker receives the DrawOverlay call. + /// + public virtual void DrawOverlay(IMarker marker, MarkerUIStates uiState, MarkerOverlayRegion region) + { + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/MarkerEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/MarkerEditor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..7cbab44875f072b6a5130a048827601d87a75191 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/MarkerEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 99c5970046bb263469514e56eb6aa519 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/MarkerTrackEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/MarkerTrackEditor.cs new file mode 100644 index 0000000000000000000000000000000000000000..192041717527360959ce5615d8dde591a3d795ad --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/MarkerTrackEditor.cs @@ -0,0 +1,18 @@ +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [CustomTimelineEditor(typeof(MarkerTrack))] + class MarkerTrackEditor : TrackEditor + { + public static readonly float DefaultMarkerTrackHeight = 24; + + public override TrackDrawOptions GetTrackOptions(TrackAsset track, Object binding) + { + var options = base.GetTrackOptions(track, binding); + options.minimumHeight = DefaultMarkerTrackHeight; + return options; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/MarkerTrackEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/MarkerTrackEditor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5c4b7a9db90918d259ec08dbe576caac888b0798 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/MarkerTrackEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 844873d1afe1c3142ab922324950e1dd +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/TrackEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/TrackEditor.cs new file mode 100644 index 0000000000000000000000000000000000000000..33f3acaeaf452b9576cb45ba058d3eace7b81317 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/TrackEditor.cs @@ -0,0 +1,309 @@ +using System; +using System.Linq; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + /// + /// The user-defined options for drawing a track." + /// + public struct TrackDrawOptions + { + /// + /// Text that indicates if the track should display an error. + /// + /// + /// If the error text is not empty or null, then the track displays a warning. The error text is used as the tooltip. + /// + public string errorText { get; set; } + + /// + /// The highlight color of the track. + /// + public Color trackColor { get; set; } + + /// + /// The minimum height of the track. + /// + public float minimumHeight { get; set; } + + /// + /// The icon displayed on the track header. + /// + /// + /// If this value is null, then the default icon for the track is used. + /// + public Texture2D icon { get; set; } + + /// + /// Indicates whether this instance and a specified object are equal. + /// + /// The object to compare with the current instance. + /// Returns true if and this instance are the same type and represent the same value. + public override bool Equals(object obj) + { + if (!(obj is TrackDrawOptions)) + return false; + + return Equals((TrackDrawOptions)obj); + } + + /// + /// Compares this object with another TrackDrawOptions. + /// + /// The object to compare with. + /// Returns true if this and are equal. + public bool Equals(TrackDrawOptions other) + { + return errorText == other.errorText && + trackColor == other.trackColor && + minimumHeight == other.minimumHeight && + icon == other.icon; + } + + /// + /// Returns the hash code for this instance. + /// + /// A 32-bit signed integer that is the hash code for this instance. + public override int GetHashCode() + { + return HashUtility.CombineHash( + errorText != null ? errorText.GetHashCode() : 0, + trackColor.GetHashCode(), + minimumHeight.GetHashCode(), + icon != null ? icon.GetHashCode() : 0 + ); + } + + /// + /// Compares two TrackDrawOptions objects. + /// + /// The first object. + /// The second object. + /// Returns true if they are equal. + public static bool operator==(TrackDrawOptions options1, TrackDrawOptions options2) + { + return options1.Equals(options2); + } + + /// + /// Compares two TrackDrawOptions objects. + /// + /// The first object. + /// The second object. + /// Returns true if they are not equal. + public static bool operator!=(TrackDrawOptions options1, TrackDrawOptions options2) + { + return !options1.Equals(options2); + } + } + + + /// + /// The errors displayed for the track binding. + /// + public enum TrackBindingErrors + { + /// + /// Select no errors. + /// + None = 0, + + /// + /// The bound GameObject is disabled. + /// + BoundGameObjectDisabled = 1 << 0, + + /// + /// The bound GameObject does not have a valid component. + /// + NoValidComponent = 1 << 1, + + /// + /// The bound Object is a disabled Behaviour. + /// + BehaviourIsDisabled = 1 << 2, + + /// + /// The bound Object is not of the correct type. + /// + InvalidBinding = 1 << 3, + + /// + /// The bound Object is part of a prefab, and not an instance. + /// + PrefabBound = 1 << 4, + + /// + /// Select all errors. + /// + All = Int32.MaxValue + } + + /// + /// Use this class to customize track types in the TimelineEditor. + /// + public class TrackEditor + { + static readonly string k_BoundGameObjectDisabled = L10n.Tr("The bound GameObject is disabled."); + static readonly string k_NoValidComponent = L10n.Tr("Could not find appropriate component on this gameObject"); + static readonly string k_RequiredComponentIsDisabled = L10n.Tr("The component is disabled"); + static readonly string k_InvalidBinding = L10n.Tr("The bound object is not the correct type."); + static readonly string k_PrefabBound = L10n.Tr("The bound object is a Prefab"); + + readonly Dictionary m_BindingCache = new Dictionary(); + + /// + /// The default height of a track. + /// + public static readonly float DefaultTrackHeight = 30.0f; + + /// + /// The minimum unscaled height of a track. + /// + public static readonly float MinimumTrackHeight = 10.0f; + + /// + /// The maximum height of a track. + /// + public static readonly float MaximumTrackHeight = 256.0f; + + /// + /// Implement this method to override the default options for drawing a track. + /// + /// The track from which track options are retrieved. + /// The binding for the track. + /// The options for drawing the track. + public virtual TrackDrawOptions GetTrackOptions(TrackAsset track, UnityEngine.Object binding) + { + return new TrackDrawOptions() + { + errorText = GetErrorText(track, binding, TrackBindingErrors.All), + minimumHeight = DefaultTrackHeight, + trackColor = GetTrackColor(track), + icon = null + }; + } + + /// + /// Gets the error text for the specified track. + /// + /// The track to retrieve options for. + /// The binding for the track. + /// The errors to check for. + /// An error to be displayed on the track, or string.Empty if there is no error. + public string GetErrorText(TrackAsset track, UnityEngine.Object boundObject, TrackBindingErrors detectErrors) + { + if (track == null || boundObject == null) + return string.Empty; + + var bindingType = GetBindingType(track); + if (bindingType != null) + { + // bound to a prefab asset + if (HasFlag(detectErrors, TrackBindingErrors.PrefabBound) && PrefabUtility.IsPartOfPrefabAsset(boundObject)) + { + return k_PrefabBound; + } + + // If we are a component, allow for bound game objects (legacy) + if (typeof(Component).IsAssignableFrom(bindingType)) + { + var gameObject = boundObject as GameObject; + var component = boundObject as Component; + if (component != null) + gameObject = component.gameObject; + + // game object is bound with no component + if (HasFlag(detectErrors, TrackBindingErrors.NoValidComponent) && gameObject != null && component == null) + { + component = gameObject.GetComponent(bindingType); + if (component == null) + { + return k_NoValidComponent; + } + } + + // attached gameObject is disables (ignores Activation Track) + if (HasFlag(detectErrors, TrackBindingErrors.BoundGameObjectDisabled) && gameObject != null && !gameObject.activeInHierarchy) + { + return k_BoundGameObjectDisabled; + } + + // component is disabled + var behaviour = component as Behaviour; + if (HasFlag(detectErrors, TrackBindingErrors.BehaviourIsDisabled) && behaviour != null && !behaviour.enabled) + { + return k_RequiredComponentIsDisabled; + } + + // mismatched binding + if (HasFlag(detectErrors, TrackBindingErrors.InvalidBinding) && component != null && !bindingType.IsAssignableFrom(component.GetType())) + { + return k_InvalidBinding; + } + } + // Mismatched binding (non-component) + else if (HasFlag(detectErrors, TrackBindingErrors.InvalidBinding) && !bindingType.IsAssignableFrom(boundObject.GetType())) + { + return k_InvalidBinding; + } + } + + return string.Empty; + } + + /// + /// Gets the color information of a track. + /// + /// + /// Returns the color for the specified track. + public Color GetTrackColor(TrackAsset track) + { + return TrackResourceCache.GetTrackColor(track); + } + + /// + /// Gets the binding type for a track. + /// + /// The track to retrieve the binding type from. + /// Returns the binding type for the specified track. Returns null if the track does not have binding. + public System.Type GetBindingType(TrackAsset track) + { + if (track == null) + return null; + + System.Type result = null; + if (m_BindingCache.TryGetValue(track, out result)) + return result; + + result = track.outputs.Select(x => x.outputTargetType).FirstOrDefault(); + m_BindingCache[track] = result; + return result; + } + + /// + /// Callback for when a track is created. + /// + /// The track that is created. + /// The source that the track is copied from. This can be set to null if the track is not a copy. + public virtual void OnCreate(TrackAsset track, TrackAsset copiedFrom) + { + } + + /// + /// Callback for when a track is changed. + /// + /// The track that is changed. + public virtual void OnTrackChanged(TrackAsset track) + { + } + + private static bool HasFlag(TrackBindingErrors errors, TrackBindingErrors flag) + { + return (errors & flag) != 0; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/TrackEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/TrackEditor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a7ae571d9553b02e598e16a77932a261781964df --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/CustomEditors/TrackEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 35cb34351b19cf44ba78afbd58746610 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/AnimatedParameterExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/AnimatedParameterExtensions.cs new file mode 100644 index 0000000000000000000000000000000000000000..26a9046a0c136be9a3397fda6ba7473613626cc5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/AnimatedParameterExtensions.cs @@ -0,0 +1,151 @@ +using System.Collections.Generic; +using JetBrains.Annotations; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class AnimatedParameterExtensions + { + public static bool HasAnyAnimatableParameters(this ICurvesOwner curvesOwner) + { + return AnimatedParameterUtility.HasAnyAnimatableParameters(curvesOwner.asset); + } + + public static IEnumerable GetAllAnimatableParameters(this ICurvesOwner curvesOwner) + { + return AnimatedParameterUtility.GetAllAnimatableParameters(curvesOwner.asset); + } + + public static bool IsParameterAnimatable(this ICurvesOwner curvesOwner, string parameterName) + { + return AnimatedParameterUtility.IsParameterAnimatable(curvesOwner.asset, parameterName); + } + + public static bool IsParameterAnimated(this ICurvesOwner curvesOwner, string parameterName) + { + return AnimatedParameterUtility.IsParameterAnimated(curvesOwner.asset, curvesOwner.curves, parameterName); + } + + public static EditorCurveBinding GetCurveBinding(this ICurvesOwner curvesOwner, string parameterName) + { + return AnimatedParameterUtility.GetCurveBinding(curvesOwner.asset, parameterName); + } + + public static string GetUniqueRecordedClipName(this ICurvesOwner curvesOwner) + { + return AnimationTrackRecorder.GetUniqueRecordedClipName(curvesOwner.assetOwner, curvesOwner.defaultCurvesName); + } + + public static AnimationCurve GetAnimatedParameter(this ICurvesOwner curvesOwner, string bindingName) + { + return AnimatedParameterUtility.GetAnimatedParameter(curvesOwner.asset, curvesOwner.curves, bindingName); + } + + public static bool AddAnimatedParameterValueAt(this ICurvesOwner curvesOwner, string parameterName, float value, float time) + { + if (!curvesOwner.IsParameterAnimatable(parameterName)) + return false; + + if (curvesOwner.curves == null) + curvesOwner.CreateCurves(curvesOwner.GetUniqueRecordedClipName()); + + var binding = curvesOwner.GetCurveBinding(parameterName); + var curve = AnimationUtility.GetEditorCurve(curvesOwner.curves, binding) ?? new AnimationCurve(); + + var serializedObject = AnimatedParameterUtility.GetSerializedPlayableAsset(curvesOwner.asset); + var property = serializedObject.FindProperty(parameterName); + + bool isStepped = property.propertyType == SerializedPropertyType.Boolean || + property.propertyType == SerializedPropertyType.Integer || + property.propertyType == SerializedPropertyType.Enum; + + TimelineUndo.PushUndo(curvesOwner.curves, "Set Key"); + CurveEditUtility.AddKeyFrameToCurve(curve, time, curvesOwner.curves.frameRate, value, isStepped); + AnimationUtility.SetEditorCurve(curvesOwner.curves, binding, curve); + + return true; + } + + public static void SanitizeCurvesData(this ICurvesOwner curvesOwner) + { + var curves = curvesOwner.curves; + if (curves == null) + return; + + // Remove any 0-length curves + foreach (var binding in AnimationUtility.GetCurveBindings(curves)) + { + var curve = AnimationUtility.GetEditorCurve(curves, binding); + if (curve.length == 0) + AnimationUtility.SetEditorCurve(curves, binding, null); + } + + // If no curves remain, delete the curves asset + if (curves.empty) + { + var track = curvesOwner.targetTrack; + var timeline = track != null ? track.timelineAsset : null; + TimelineUndo.PushDestroyUndo(timeline, track, curves); + } + } + + public static bool AddAnimatedParameter(this ICurvesOwner curvesOwner, string parameterName) + { + var newBinding = new EditorCurveBinding(); + + SerializedProperty property; + if (!InternalAddParameter(curvesOwner, parameterName, ref newBinding, out property)) + return false; + + var duration = (float)curvesOwner.duration; + CurveEditUtility.AddKey(curvesOwner.curves, newBinding, property, 0); + CurveEditUtility.AddKey(curvesOwner.curves, newBinding, property, duration); + return true; + } + + public static bool RemoveAnimatedParameter(this ICurvesOwner curvesOwner, string parameterName) + { + if (!curvesOwner.IsParameterAnimated(parameterName) || curvesOwner.curves == null) + return false; + + var binding = curvesOwner.GetCurveBinding(parameterName); + AnimationUtility.SetEditorCurve(curvesOwner.curves, binding, null); + return true; + } + + // Set an animated parameter. Requires the field identifier 'position.x', but will add default curves to all fields + public static bool SetAnimatedParameter(this ICurvesOwner curvesOwner, string parameterName, AnimationCurve curve) + { + // this will add a basic curve for all the related parameters + if (!curvesOwner.IsParameterAnimated(parameterName) && !curvesOwner.AddAnimatedParameter(parameterName)) + return false; + + var binding = curvesOwner.GetCurveBinding(parameterName); + AnimationUtility.SetEditorCurve(curvesOwner.curves, binding, curve); + return true; + } + + static bool InternalAddParameter([NotNull] ICurvesOwner curvesOwner, string parameterName, ref EditorCurveBinding binding, out SerializedProperty property) + { + property = null; + + if (curvesOwner.IsParameterAnimated(parameterName)) + return false; + + var serializedObject = AnimatedParameterUtility.GetSerializedPlayableAsset(curvesOwner.asset); + if (serializedObject == null) + return false; + + property = serializedObject.FindProperty(parameterName); + if (property == null || !AnimatedParameterUtility.IsTypeAnimatable(property.propertyType)) + return false; + + if (curvesOwner.curves == null) + curvesOwner.CreateCurves(curvesOwner.GetUniqueRecordedClipName()); + + binding = curvesOwner.GetCurveBinding(parameterName); + return true; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/AnimatedParameterExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/AnimatedParameterExtensions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..21de3d3a7d2743294f591bf9ec3427c9384b1139 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/AnimatedParameterExtensions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 7d3aa106cfe752241997b3759bf80163 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/AnimationTrackExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/AnimationTrackExtensions.cs new file mode 100644 index 0000000000000000000000000000000000000000..5c9eb7c970d0559edebb08a5fe1405a37559cc89 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/AnimationTrackExtensions.cs @@ -0,0 +1,134 @@ +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class AnimationTrackExtensions + { + public static void ConvertToClipMode(this AnimationTrack track) + { + if (!track.CanConvertToClipMode()) + return; + + UndoExtensions.RegisterTrack(track, "Convert To Clip"); + + if (!track.infiniteClip.empty) + { + var animClip = track.infiniteClip; + TimelineUndo.PushUndo(animClip, "Convert To Clip"); + UndoExtensions.RegisterTrack(track, "Convert To Clip"); + var start = AnimationClipCurveCache.Instance.GetCurveInfo(animClip).keyTimes.FirstOrDefault(); + animClip.ShiftBySeconds(-start); + + track.infiniteClip = null; + var clip = track.CreateClip(animClip); + + clip.start = start; + clip.preExtrapolationMode = track.infiniteClipPreExtrapolation; + clip.postExtrapolationMode = track.infiniteClipPostExtrapolation; + clip.recordable = true; + if (Mathf.Abs(animClip.length) < TimelineClip.kMinDuration) + { + clip.duration = 1; + } + + var animationAsset = clip.asset as AnimationPlayableAsset; + if (animationAsset) + { + animationAsset.position = track.infiniteClipOffsetPosition; + animationAsset.eulerAngles = track.infiniteClipOffsetEulerAngles; + + // going to / from infinite mode should reset this. infinite mode + animationAsset.removeStartOffset = track.infiniteClipRemoveOffset; + animationAsset.applyFootIK = track.infiniteClipApplyFootIK; + animationAsset.loop = track.infiniteClipLoop; + + track.infiniteClipOffsetPosition = Vector3.zero; + track.infiniteClipOffsetEulerAngles = Vector3.zero; + } + + track.CalculateExtrapolationTimes(); + } + + track.infiniteClip = null; + + EditorUtility.SetDirty(track); + } + + public static void ConvertFromClipMode(this AnimationTrack track, TimelineAsset timeline) + { + if (!track.CanConvertFromClipMode()) + return; + + UndoExtensions.RegisterTrack(track, "Convert From Clip"); + + var clip = track.clips[0]; + var delta = (float)clip.start; + track.infiniteClipTimeOffset = 0.0f; + track.infiniteClipPreExtrapolation = clip.preExtrapolationMode; + track.infiniteClipPostExtrapolation = clip.postExtrapolationMode; + + var animAsset = clip.asset as AnimationPlayableAsset; + if (animAsset) + { + track.infiniteClipOffsetPosition = animAsset.position; + track.infiniteClipOffsetEulerAngles = animAsset.eulerAngles; + track.infiniteClipRemoveOffset = animAsset.removeStartOffset; + track.infiniteClipApplyFootIK = animAsset.applyFootIK; + track.infiniteClipLoop = animAsset.loop; + } + + // clone it, it may not be in the same asset + var animClip = clip.animationClip; + + float scale = (float)clip.timeScale; + if (!Mathf.Approximately(scale, 1.0f)) + { + if (!Mathf.Approximately(scale, 0.0f)) + scale = 1.0f / scale; + animClip.ScaleTime(scale); + } + + TimelineUndo.PushUndo(animClip, "Convert From Clip"); + animClip.ShiftBySeconds(delta); + + // manually delete the clip + var asset = clip.asset; + clip.asset = null; + + // Remove the clip, remove old assets + ClipModifier.Delete(timeline, clip); + TimelineUndo.PushDestroyUndo(null, track, asset); + + track.infiniteClip = animClip; + + EditorUtility.SetDirty(track); + } + + public static bool CanConvertToClipMode(this AnimationTrack track) + { + if (track == null || track.inClipMode) + return false; + return (track.infiniteClip != null && !track.infiniteClip.empty); + } + + // Requirements to go from clip mode + // - one clip, recordable, and animation clip belongs to the same asset as the track + public static bool CanConvertFromClipMode(this AnimationTrack track) + { + if ((track == null) || + (!track.inClipMode) || + (track.clips.Length != 1) || + (track.clips[0].start < 0) || + (!track.clips[0].recordable)) + return false; + + var asset = track.clips[0].asset as AnimationPlayableAsset; + if (asset == null) + return false; + + return TimelineHelpers.HaveSameContainerAsset(track, asset.clip); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/AnimationTrackExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/AnimationTrackExtensions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..df81151848db5322c7f8788ad08279f6b7f05649 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/AnimationTrackExtensions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5a31542ccf4e8584ca4f60843e9d02d0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/TrackExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/TrackExtensions.cs new file mode 100644 index 0000000000000000000000000000000000000000..cf28a2b88dcd5fc6ee26cc832650adc887ae5c72 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/TrackExtensions.cs @@ -0,0 +1,505 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + /// + /// Editor-only extension methods on track assets. + /// + static class TrackExtensions + { + public static readonly double kMinOverlapTime = TimeUtility.kTimeEpsilon * 1000; + + public static AnimationClip GetOrCreateClip(this AnimationTrack track) + { + if (track.infiniteClip == null && !track.inClipMode) + track.CreateInfiniteClip(AnimationTrackRecorder.GetUniqueRecordedClipName(track, AnimationTrackRecorder.kRecordClipDefaultName)); + + return track.infiniteClip; + } + + public static TimelineClip CreateClip(this TrackAsset track, double time) + { + var attr = track.GetType().GetCustomAttributes(typeof(TrackClipTypeAttribute), true); + + if (attr.Length == 0) + return null; + + if (TimelineWindow.instance.state == null) + return null; + + if (attr.Length == 1) + { + var clipClass = (TrackClipTypeAttribute)attr[0]; + + var clip = TimelineHelpers.CreateClipOnTrack(clipClass.inspectedType, track, time); + return clip; + } + + return null; + } + + static bool Overlaps(TimelineClip blendOut, TimelineClip blendIn) + { + if (blendIn == blendOut) + return false; + + if (Math.Abs(blendIn.start - blendOut.start) < TimeUtility.kTimeEpsilon) + { + return blendIn.duration >= blendOut.duration; + } + + return blendIn.start >= blendOut.start && blendIn.start < blendOut.end; + } + + public static void ComputeBlendsFromOverlaps(this TrackAsset asset) + { + ComputeBlendsFromOverlaps(asset.clips); + } + + internal static void ComputeBlendsFromOverlaps(TimelineClip[] clips) + { + foreach (var clip in clips) + { + clip.blendInDuration = -1; + clip.blendOutDuration = -1; + } + + foreach (var clip in clips) + { + var blendIn = clip; + var blendOut = clips + .Where(c => Overlaps(c, blendIn)) + .OrderBy(c => c.start) + .FirstOrDefault(); + + if (blendOut != null) + { + UpdateClipIntersection(blendOut, blendIn); + } + } + } + + internal static void UpdateClipIntersection(TimelineClip blendOutClip, TimelineClip blendInClip) + { + if (!blendOutClip.SupportsBlending() || !blendInClip.SupportsBlending()) + return; + + if (blendInClip.end < blendOutClip.end) + return; + + double duration = Math.Max(0, blendOutClip.start + blendOutClip.duration - blendInClip.start); + duration = duration <= kMinOverlapTime ? 0 : duration; + blendOutClip.blendOutDuration = duration; + blendInClip.blendInDuration = duration; + + var blendInMode = blendInClip.blendInCurveMode; + var blendOutMode = blendOutClip.blendOutCurveMode; + + if (blendInMode == TimelineClip.BlendCurveMode.Manual && blendOutMode == TimelineClip.BlendCurveMode.Auto) + { + blendOutClip.mixOutCurve = CurveEditUtility.CreateMatchingCurve(blendInClip.mixInCurve); + } + else if (blendInMode == TimelineClip.BlendCurveMode.Auto && blendOutMode == TimelineClip.BlendCurveMode.Manual) + { + blendInClip.mixInCurve = CurveEditUtility.CreateMatchingCurve(blendOutClip.mixOutCurve); + } + else if (blendInMode == TimelineClip.BlendCurveMode.Auto && blendOutMode == TimelineClip.BlendCurveMode.Auto) + { + blendInClip.mixInCurve = null; // resets to default curves + blendOutClip.mixOutCurve = null; + } + } + + internal static void RecursiveSubtrackClone(TrackAsset source, TrackAsset duplicate, IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, PlayableAsset assetOwner) + { + var subtracks = source.GetChildTracks(); + foreach (var sub in subtracks) + { + var newSub = TimelineHelpers.Clone(duplicate, sub, sourceTable, destTable, assetOwner); + duplicate.AddChild(newSub); + RecursiveSubtrackClone(sub, newSub, sourceTable, destTable, assetOwner); + + // Call the custom editor on Create + var customEditor = CustomTimelineEditorCache.GetTrackEditor(newSub); + try + { + customEditor.OnCreate(newSub, sub); + } + catch (Exception e) + { + Debug.LogException(e); + } + + // registration has to happen AFTER recursion + TimelineCreateUtilities.SaveAssetIntoObject(newSub, assetOwner); + TimelineUndo.RegisterCreatedObjectUndo(newSub, "Duplicate"); + } + } + + internal static TrackAsset Duplicate(this TrackAsset track, IExposedPropertyTable sourceTable, IExposedPropertyTable destTable, + TimelineAsset destinationTimeline = null) + { + if (track == null) + return null; + + // if the destination is us, clear to avoid bad parenting (case 919421) + if (destinationTimeline == track.timelineAsset) + destinationTimeline = null; + + var timelineParent = track.parent as TimelineAsset; + var trackParent = track.parent as TrackAsset; + if (timelineParent == null && trackParent == null) + { + Debug.LogWarning("Cannot duplicate track because it is not parented to known type"); + return null; + } + + // Determine who the final parent is. If we are pasting into another track, it's always the timeline. + // Otherwise it's the original parent + PlayableAsset finalParent = destinationTimeline != null ? destinationTimeline : track.parent; + + // grab the list of tracks to generate a name from (923360) to get the list of names + // no need to do this part recursively + var finalTrackParent = finalParent as TrackAsset; + var finalTimelineAsset = finalParent as TimelineAsset; + var otherTracks = (finalTimelineAsset != null) ? finalTimelineAsset.trackObjects : finalTrackParent.subTracksObjects; + + // Important to create the new objects before pushing the original undo, or redo breaks the + // sequence + var newTrack = TimelineHelpers.Clone(finalParent, track, sourceTable, destTable, finalParent); + newTrack.name = TimelineCreateUtilities.GenerateUniqueActorName(otherTracks, newTrack.name); + + RecursiveSubtrackClone(track, newTrack, sourceTable, destTable, finalParent); + TimelineCreateUtilities.SaveAssetIntoObject(newTrack, finalParent); + TimelineUndo.RegisterCreatedObjectUndo(newTrack, "Duplicate"); + UndoExtensions.RegisterPlayableAsset(finalParent, "Duplicate"); + + if (destinationTimeline != null) // other timeline + destinationTimeline.AddTrackInternal(newTrack); + else if (timelineParent != null) // this timeline, no parent + ReparentTracks(new List { newTrack }, timelineParent, timelineParent.GetRootTracks().Last(), false); + else // this timeline, with parent + trackParent.AddChild(newTrack); + + // Call the custom editor. this check prevents the call when copying to the clipboard + if (destinationTimeline == null || destinationTimeline == TimelineEditor.inspectedAsset) + { + var customEditor = CustomTimelineEditorCache.GetTrackEditor(newTrack); + try + { + customEditor.OnCreate(newTrack, track); + } + catch (Exception e) + { + Debug.LogException(e); + } + } + + return newTrack; + } + + // Reparents a list of tracks to a new parent + // the new parent cannot be null (has to be track asset or sequence) + // the insertAfter can be null (will not reorder) + internal static bool ReparentTracks(List tracksToMove, PlayableAsset targetParent, + TrackAsset insertMarker = null, bool insertBefore = false) + { + var targetParentTrack = targetParent as TrackAsset; + var targetSequenceTrack = targetParent as TimelineAsset; + + if (tracksToMove == null || tracksToMove.Count == 0 || (targetParentTrack == null && targetSequenceTrack == null)) + return false; + + // invalid parent type on a track + if (targetParentTrack != null && tracksToMove.Any(x => !TimelineCreateUtilities.ValidateParentTrack(targetParentTrack, x.GetType()))) + return false; + + // no valid tracks means this is simply a rearrangement + var validTracks = tracksToMove.Where(x => x.parent != targetParent).ToList(); + if (insertMarker == null && !validTracks.Any()) + return false; + + var parents = validTracks.Select(x => x.parent).Where(x => x != null).Distinct().ToList(); + // push the current state of the tracks that will change + foreach (var p in parents) + { + UndoExtensions.RegisterPlayableAsset(p, "Reparent"); + } + UndoExtensions.RegisterTracks(validTracks, "Reparent"); + UndoExtensions.RegisterPlayableAsset(targetParent, "Reparent"); + + // need to reparent tracks first, before moving them. + foreach (var t in validTracks) + { + if (t.parent != targetParent) + { + TrackAsset toMoveParent = t.parent as TrackAsset; + TimelineAsset toMoveTimeline = t.parent as TimelineAsset; + if (toMoveTimeline != null) + { + toMoveTimeline.RemoveTrack(t); + } + else if (toMoveParent != null) + { + toMoveParent.RemoveSubTrack(t); + } + + if (targetParentTrack != null) + { + targetParentTrack.AddChild(t); + targetParentTrack.SetCollapsed(false); + } + else + { + targetSequenceTrack.AddTrackInternal(t); + } + } + } + + + if (insertMarker != null) + { + // re-ordering track. This is using internal APIs, so invalidation of the tracks must be done manually to avoid + // cache mismatches + var children = targetParentTrack != null ? targetParentTrack.subTracksObjects : targetSequenceTrack.trackObjects; + TimelineUtility.ReorderTracks(children, tracksToMove, insertMarker, insertBefore); + if (targetParentTrack != null) + targetParentTrack.Invalidate(); + if (insertMarker.timelineAsset != null) + insertMarker.timelineAsset.Invalidate(); + } + + return true; + } + + internal static IEnumerable FilterTracks(IEnumerable tracks) + { + var nTracks = tracks.Count(); + // Duplicate is recursive. If should not have parent and child in the list + var hash = new HashSet(tracks); + var take = new Dictionary(nTracks); + + foreach (var track in tracks) + { + var parent = track.parent as TrackAsset; + var foundParent = false; + // go up the hierarchy + while (parent != null && !foundParent) + { + if (hash.Contains(parent)) + { + foundParent = true; + } + + parent = parent.parent as TrackAsset; + } + + take[track] = !foundParent; + } + + foreach (var track in tracks) + { + if (take[track]) + yield return track; + } + } + + internal static bool IsVisibleRecursive(this TrackAsset track) + { + var t = track; + while ((t = t.parent as TrackAsset) != null) + { + if (t.GetCollapsed()) + return false; + } + + return true; + } + + internal static bool GetCollapsed(this TrackAsset track) + { + return TimelineWindowViewPrefs.IsTrackCollapsed(track); + } + + internal static void SetCollapsed(this TrackAsset track, bool collapsed) + { + TimelineWindowViewPrefs.SetTrackCollapsed(track, collapsed); + } + + internal static bool GetShowMarkers(this TrackAsset track) + { + return TimelineWindowViewPrefs.IsShowMarkers(track); + } + + internal static void SetShowMarkers(this TrackAsset track, bool collapsed) + { + TimelineWindowViewPrefs.SetTrackShowMarkers(track, collapsed); + } + + internal static bool GetShowInlineCurves(this TrackAsset track) + { + return TimelineWindowViewPrefs.GetShowInlineCurves(track); + } + + internal static void SetShowInlineCurves(this TrackAsset track, bool inlineOn) + { + TimelineWindowViewPrefs.SetShowInlineCurves(track, inlineOn); + } + + internal static bool ShouldShowInfiniteClipEditor(this AnimationTrack track) + { + return track != null && !track.inClipMode && track.infiniteClip != null; + } + + // Special method to remove a track that is in a broken state. i.e. the script won't load + internal static bool RemoveBrokenTrack(PlayableAsset parent, ScriptableObject track) + { + var parentTrack = parent as TrackAsset; + var parentTimeline = parent as TimelineAsset; + + if (parentTrack == null && parentTimeline == null) + throw new ArgumentException("parent is not a valid parent type", "parent"); + + // this object must be a Unity null, but not actually null; + object trackAsObject = track; + if (trackAsObject == null || track != null) // yes, this is correct + throw new ArgumentException("track is not in a broken state"); + + // this belongs to a parent track + if (parentTrack != null) + { + int index = parentTrack.subTracksObjects.FindIndex(t => t.GetInstanceID() == track.GetInstanceID()); + if (index >= 0) + { + UndoExtensions.RegisterTrack(parentTrack, "Remove Track"); + parentTrack.subTracksObjects.RemoveAt(index); + parentTrack.Invalidate(); + Undo.DestroyObjectImmediate(track); + return true; + } + } + else if (parentTimeline != null) + { + int index = parentTimeline.trackObjects.FindIndex(t => t.GetInstanceID() == track.GetInstanceID()); + if (index >= 0) + { + UndoExtensions.RegisterPlayableAsset(parentTimeline, "Remove Track"); + parentTimeline.trackObjects.RemoveAt(index); + parentTimeline.Invalidate(); + Undo.DestroyObjectImmediate(track); + return true; + } + } + + return false; + } + + // Find the gap at the given time + // return true if there is a gap, false if there is an intersection + // endGap will be Infinity if the gap has no end + internal static bool GetGapAtTime(this TrackAsset track, double time, out double startGap, out double endGap) + { + startGap = 0; + endGap = Double.PositiveInfinity; + + if (track == null || !track.GetClips().Any()) + { + return false; + } + + var discreteTime = new DiscreteTime(time); + + track.SortClips(); + var sortedByStartTime = track.clips; + for (int i = 0; i < sortedByStartTime.Length; i++) + { + var clip = sortedByStartTime[i]; + + // intersection + if (discreteTime >= new DiscreteTime(clip.start) && discreteTime < new DiscreteTime(clip.end)) + { + endGap = time; + startGap = time; + return false; + } + + if (clip.end < time) + { + startGap = clip.end; + } + if (clip.start > time) + { + endGap = clip.start; + break; + } + } + + if (endGap - startGap < TimelineClip.kMinDuration) + { + startGap = time; + endGap = time; + return false; + } + + return true; + } + + public static bool IsCompatibleWithClip(this TrackAsset track, TimelineClip clip) + { + if (track == null || clip == null || clip.asset == null) + return false; + + return TypeUtility.GetPlayableAssetsHandledByTrack(track.GetType()).Contains(clip.asset.GetType()); + } + + // Get a flattened list of all child tracks + public static void GetFlattenedChildTracks(this TrackAsset asset, List list) + { + if (asset == null || list == null) + return; + + foreach (var track in asset.GetChildTracks()) + { + list.Add(track); + GetFlattenedChildTracks(track, list); + } + } + + public static IEnumerable GetFlattenedChildTracks(this TrackAsset asset) + { + if (asset == null || !asset.GetChildTracks().Any()) + return Enumerable.Empty(); + + var flattenedChildTracks = new List(); + GetFlattenedChildTracks(asset, flattenedChildTracks); + return flattenedChildTracks; + } + + public static void UnarmForRecord(this TrackAsset track) + { + TimelineWindow.instance.state.UnarmForRecord(track); + } + + public static void SetShowTrackMarkers(this TrackAsset track, bool showMarkerHeader) + { + var currentValue = track.GetShowMarkers(); + if (currentValue != showMarkerHeader) + { + TimelineUndo.PushUndo(TimelineWindow.instance.state.editSequence.viewModel, "Toggle Show Markers"); + track.SetShowMarkers(showMarkerHeader); + if (!showMarkerHeader) + { + foreach (var marker in track.GetMarkers()) + { + SelectionManager.Remove(marker); + } + } + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/TrackExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/TrackExtensions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1e9f0c22c050298e4943feb3038fbb4d7341838c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Extensions/TrackExtensions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5b24618beecc3bf41acadfcf2246d772 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ClipItem.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ClipItem.cs new file mode 100644 index 0000000000000000000000000000000000000000..6724870aaf26f675fa9412f84afbcf83f48d33a6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ClipItem.cs @@ -0,0 +1,145 @@ +using System; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class ClipItem : IBlendable, ITrimmable + { + readonly TimelineClip m_Clip; + + public TimelineClip clip + { + get { return m_Clip; } + } + + public ClipItem(TimelineClip clip) + { + m_Clip = clip; + } + + public TrackAsset parentTrack + { + get { return m_Clip.parentTrack; } + set { m_Clip.parentTrack = value; } + } + + public double start + { + get { return m_Clip.start; } + set { m_Clip.start = value; } + } + + public double end + { + get { return m_Clip.end; } + } + + public double duration + { + get { return m_Clip.duration; } + } + + public bool IsCompatibleWithTrack(TrackAsset track) + { + return track.IsCompatibleWithClip(m_Clip); + } + + public void PushUndo(string operation) + { + UndoExtensions.RegisterClip(m_Clip, operation); + } + + public TimelineItemGUI gui + { + get { return ItemToItemGui.GetGuiForClip(m_Clip); } + } + + public bool supportsBlending + { + get { return m_Clip.SupportsBlending(); } + } + + public bool hasLeftBlend + { + get { return m_Clip.hasBlendIn; } + } + + public bool hasRightBlend + { + get { return m_Clip.hasBlendOut; } + } + + public double leftBlendDuration + { + get { return m_Clip.hasBlendIn ? m_Clip.blendInDuration : m_Clip.easeInDuration; } + } + + public double rightBlendDuration + { + get { return m_Clip.hasBlendOut ? m_Clip.blendOutDuration : m_Clip.easeOutDuration; } + } + + public void SetStart(double time, bool affectTimeScale) + { + ClipModifier.SetStart(m_Clip, time, affectTimeScale); + m_Clip.ConformEaseValues(); + } + + public void SetEnd(double time, bool affectTimeScale) + { + ClipModifier.SetEnd(m_Clip, time, affectTimeScale); + m_Clip.ConformEaseValues(); + } + + public void Delete() + { + EditorClipFactory.RemoveEditorClip(m_Clip); + ClipModifier.Delete(m_Clip.parentTrack.timelineAsset, m_Clip); + } + + public void TrimStart(double time) + { + ClipModifier.TrimStart(m_Clip, time); + } + + public void TrimEnd(double time) + { + ClipModifier.TrimEnd(m_Clip, time); + } + + public ITimelineItem CloneTo(TrackAsset parent, double time) + { + return new ClipItem(TimelineHelpers.Clone(m_Clip, TimelineEditor.inspectedDirector, TimelineEditor.inspectedDirector, time, parent)); + } + + public override string ToString() + { + return m_Clip.ToString(); + } + + public bool Equals(ClipItem otherClip) + { + if (ReferenceEquals(null, otherClip)) return false; + if (ReferenceEquals(this, otherClip)) return true; + return Equals(m_Clip, otherClip.m_Clip); + } + + public override int GetHashCode() + { + return (m_Clip != null ? m_Clip.GetHashCode() : 0); + } + + public bool Equals(ITimelineItem other) + { + return Equals((object)other); + } + + public override bool Equals(object obj) + { + if (ReferenceEquals(null, obj)) return false; + if (ReferenceEquals(this, obj)) return true; + var other = obj as ClipItem; + return other != null && Equals(other); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ClipItem.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ClipItem.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..df9784043f7b5b7ed216beef88cad9addd8e0660 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ClipItem.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d143f3edd0494bc4c98a421bd59564fa +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ITimelineItem.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ITimelineItem.cs new file mode 100644 index 0000000000000000000000000000000000000000..93e9917a06198bd3997e1133046d29683ac8d55a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ITimelineItem.cs @@ -0,0 +1,39 @@ +using System; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + interface ITimelineItem : IEquatable + { + double start { get; set; } + double end { get; } + double duration { get; } + + TrackAsset parentTrack { get; set; } + bool IsCompatibleWithTrack(TrackAsset track); + + void Delete(); + ITimelineItem CloneTo(TrackAsset parent, double time); + void PushUndo(string operation); + + TimelineItemGUI gui { get; } + } + + interface ITrimmable : ITimelineItem + { + void SetStart(double time, bool affectTimeScale); + void SetEnd(double time, bool affectTimeScale); + void TrimStart(double time); + void TrimEnd(double time); + } + + interface IBlendable : ITimelineItem + { + bool supportsBlending { get; } + bool hasLeftBlend { get; } + bool hasRightBlend { get; } + + double leftBlendDuration { get; } + double rightBlendDuration { get; } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ITimelineItem.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ITimelineItem.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a23827c044e876231427698ac493b5ca54475a1d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ITimelineItem.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2c87ec8c97244cd47945ec90a99abe35 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsGroup.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsGroup.cs new file mode 100644 index 0000000000000000000000000000000000000000..41ff6578a1ffb7e2af69951432e18a121c2ff131 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsGroup.cs @@ -0,0 +1,63 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class ItemsGroup + { + readonly ITimelineItem[] m_Items; + readonly ITimelineItem m_LeftMostItem; + readonly ITimelineItem m_RightMostItem; + + public ITimelineItem[] items + { + get { return m_Items; } + } + + public double start + { + get { return m_LeftMostItem.start; } + set + { + var offset = value - m_LeftMostItem.start; + + foreach (var clip in m_Items) + clip.start += offset; + } + } + + public double end + { + get { return m_RightMostItem.end; } + } + + public ITimelineItem leftMostItem + { + get { return m_LeftMostItem; } + } + + public ITimelineItem rightMostItem + { + get { return m_RightMostItem; } + } + + public ItemsGroup(IEnumerable items) + { + Debug.Assert(items != null && items.Any()); + + m_Items = items.ToArray(); + m_LeftMostItem = null; + m_RightMostItem = null; + + foreach (var item in m_Items) + { + if (m_LeftMostItem == null || item.start < m_LeftMostItem.start) + m_LeftMostItem = item; + + if (m_RightMostItem == null || item.end > m_RightMostItem.end) + m_RightMostItem = item; + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsGroup.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsGroup.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1da6246a193115d7c623de93078d9c218e775d21 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsGroup.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1ec4b8ec4b34f4344bac53c19288eaa2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsPerTrack.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsPerTrack.cs new file mode 100644 index 0000000000000000000000000000000000000000..78a86ef87390fb10f47868da5b8c5848691a5822 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsPerTrack.cs @@ -0,0 +1,45 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class ItemsPerTrack + { + public virtual TrackAsset targetTrack { get; } + + public IEnumerable items + { + get { return m_ItemsGroup.items; } + } + + public IEnumerable clips + { + get { return m_ItemsGroup.items.OfType().Select(i => i.clip); } + } + + public IEnumerable markers + { + get { return m_ItemsGroup.items.OfType().Select(i => i.marker); } + } + + public ITimelineItem leftMostItem + { + get { return m_ItemsGroup.leftMostItem; } + } + + public ITimelineItem rightMostItem + { + get { return m_ItemsGroup.rightMostItem; } + } + + protected readonly ItemsGroup m_ItemsGroup; + + public ItemsPerTrack(TrackAsset targetTrack, IEnumerable items) + { + this.targetTrack = targetTrack; + m_ItemsGroup = new ItemsGroup(items); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsPerTrack.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsPerTrack.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..77da4aea9f3e87ed34810459930c1dc848a8063c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsPerTrack.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 647e1bbd3809b30459d946b4a1ddf22b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsUtils.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsUtils.cs new file mode 100644 index 0000000000000000000000000000000000000000..58eb002cc256c874af5cd0b365353b9a1bc25ab5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsUtils.cs @@ -0,0 +1,116 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class ItemsUtils + { + static readonly Dictionary s_ClipCache = new Dictionary(); + static readonly Dictionary s_MarkerCache = new Dictionary(); + + public static IEnumerable ToItemsPerTrack(this IEnumerable items) + { + var groupedItems = items.GroupBy(c => c.parentTrack); + foreach (var group in groupedItems) + { + yield return new ItemsPerTrack(group.Key, group.ToArray()); + } + } + + public static ITimelineItem ToItem(this TimelineClip clip) + { + if (s_ClipCache.ContainsKey(clip)) + return s_ClipCache[clip]; + + var ret = new ClipItem(clip); + s_ClipCache.Add(clip, ret); + return ret; + } + + public static ITimelineItem ToItem(this IMarker marker) + { + if (s_MarkerCache.ContainsKey(marker)) + return s_MarkerCache[marker]; + + var ret = new MarkerItem(marker); + s_MarkerCache.Add(marker, ret); + return ret; + } + + public static IEnumerable ToItems(this IEnumerable clips) + { + return clips.Select(ToItem); + } + + public static IEnumerable ToItems(this IEnumerable markers) + { + return markers.Select(ToItem); + } + + public static IEnumerable GetItems(this TrackAsset track) + { + var list = track.clips.Select(clip => (ITimelineItem) new ClipItem(clip)).ToList(); + list.AddRange(track.GetMarkers().Select(marker => (ITimelineItem) new MarkerItem(marker))); + + list = list.OrderBy(x => x.start).ThenBy(x => x.end).ToList(); + return list; + } + + public static void GetItemRange(this TrackAsset track, out double start, out double end) + { + start = 0; + end = 0; + var items = track.GetItems().ToList(); + if (items.Any()) + { + start = items.Min(p => p.start); + end = items.Max(p => p.end); + } + } + + public static IEnumerable GetItemsExcept(this TrackAsset track, IEnumerable items) + { + return GetItems(track).Except(items); + } + + public static IEnumerable GetItemTypes(IEnumerable items) + { + var types = new List(); + if (items.OfType().Any()) + types.Add(typeof(ClipItem)); + if (items.OfType().Any()) + types.Add(typeof(MarkerItem)); + + return types; + } + + public static IEnumerable GetItemTypes(IEnumerable itemsGroups) + { + return GetItemTypes(itemsGroups.SelectMany(i => i.items)).Distinct(); + } + + public static void SetItemsStartTime(IEnumerable newItems, double time) + { + var startTimes = newItems.Select(d => d.items.Min(x => x.start)).ToList(); + var min = startTimes.Min(); + startTimes = startTimes.Select(x => x - min + time).ToList(); + + for (int i = 0; i < newItems.Count(); ++i) + EditModeUtils.SetStart(newItems.ElementAt(i).items, startTimes[i]); + } + + public static double TimeGapBetweenItems(ITimelineItem leftItem, ITimelineItem rightItem) + { + if (leftItem is MarkerItem && rightItem is MarkerItem) + { + var markerType = ((MarkerItem)leftItem).marker.GetType(); + var gap = TimeReferenceUtility.PixelToTime(StyleManager.UssStyleForType(markerType).fixedWidth) - TimeReferenceUtility.PixelToTime(0); + return gap; + } + + return 0.0; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsUtils.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsUtils.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..65dca1e789137fa28b4472aef418ad4be39cd306 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/ItemsUtils.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5653477a5039f674da8f856adcf47172 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/MarkerItem.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/MarkerItem.cs new file mode 100644 index 0000000000000000000000000000000000000000..bb5e29ba371d4207c010056d1a45b86b13f88375 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/MarkerItem.cs @@ -0,0 +1,98 @@ +using System; +using UnityEngine.Timeline; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class MarkerItem : ITimelineItem + { + readonly IMarker m_Marker; + + public IMarker marker + { + get { return m_Marker; } + } + + public MarkerItem(IMarker marker) + { + m_Marker = marker; + } + + public TrackAsset parentTrack + { + get { return m_Marker.parent; } + set {} + } + + public double start + { + get { return m_Marker.time; } + set { m_Marker.time = value; } + } + + public double end + { + get { return m_Marker.time; } + } + + public double duration + { + get { return 0.0; } + } + + public bool IsCompatibleWithTrack(TrackAsset track) + { + return TypeUtility.DoesTrackSupportMarkerType(track, m_Marker.GetType()); + } + + public void PushUndo(string operation) + { + UndoExtensions.RegisterMarker(m_Marker, operation); + } + + public TimelineItemGUI gui + { + get { return ItemToItemGui.GetGuiForMarker(m_Marker); } + } + + public void Delete() + { + MarkerModifier.DeleteMarker(m_Marker); + } + + public ITimelineItem CloneTo(TrackAsset parent, double time) + { + var item = new MarkerItem(MarkerModifier.CloneMarkerToParent(m_Marker, parent)); + item.start = time; + return item; + } + + protected bool Equals(MarkerItem otherMarker) + { + return Equals(m_Marker, otherMarker.m_Marker); + } + + public override int GetHashCode() + { + return (m_Marker != null ? m_Marker.GetHashCode() : 0); + } + + public override string ToString() + { + return m_Marker.ToString(); + } + + public bool Equals(ITimelineItem other) + { + return Equals((object)other); + } + + public override bool Equals(object obj) + { + if (ReferenceEquals(null, obj)) return false; + if (ReferenceEquals(this, obj)) return true; + var other = obj as MarkerItem; + return other != null && Equals(other); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/MarkerItem.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/MarkerItem.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..8d20ad8103d5c251c4ed3e75b95c8a5710243d92 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Items/MarkerItem.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 452534715106564439d2240d82999d88 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/AddDelete.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/AddDelete.meta new file mode 100644 index 0000000000000000000000000000000000000000..b18202d8b1cdde2f190a5150abbbea578dd70952 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/AddDelete.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: db34f310723c62440a05d3e69f262a70 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Cursors.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Cursors.meta new file mode 100644 index 0000000000000000000000000000000000000000..0647cb5f51b86212b962fd88caac98175766f914 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Cursors.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 4ad09461bf994e54da846f726a23118e +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/EditMode.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/EditMode.cs new file mode 100644 index 0000000000000000000000000000000000000000..278489cc77de1e1e7af53aea870e88e1bdcb611c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/EditMode.cs @@ -0,0 +1,344 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class EditMode + { + public enum EditType + { + None = -1, + Mix = 0, + Ripple = 1, + Replace = 2 + } + + interface ISubEditMode + { + IMoveItemMode moveItemMode { get; } + IMoveItemDrawer moveItemDrawer { get; } + ITrimItemMode trimItemMode { get; } + ITrimItemDrawer trimItemDrawer { get; } + IAddDeleteItemMode addDeleteItemMode { get; } + + Color color { get; } + KeyCode clutchKey { get; } + + void Reset(); + } + + class SubEditMode: ISubEditMode + where TMoveMode : class, IMoveItemMode, IMoveItemDrawer, new() + where TTrimMode : class, ITrimItemMode, ITrimItemDrawer, new() + where TAddDeleteMode : class, IAddDeleteItemMode, new() + { + public SubEditMode(Color guiColor, KeyCode key) + { + color = guiColor; + clutchKey = key; + Reset(); + } + + public void Reset() + { + m_MoveItemMode = new TMoveMode(); + m_TrimItemMode = new TTrimMode(); + m_AddDeleteItemMode = new TAddDeleteMode(); + } + + TMoveMode m_MoveItemMode; + TTrimMode m_TrimItemMode; + TAddDeleteMode m_AddDeleteItemMode; + + public IMoveItemMode moveItemMode { get { return m_MoveItemMode; } } + public IMoveItemDrawer moveItemDrawer { get { return m_MoveItemMode; } } + public ITrimItemMode trimItemMode { get { return m_TrimItemMode; } } + public ITrimItemDrawer trimItemDrawer { get { return m_TrimItemMode; } } + public IAddDeleteItemMode addDeleteItemMode { get { return m_AddDeleteItemMode; } } + public Color color { get; } + public KeyCode clutchKey { get; } + } + + static readonly Dictionary k_EditModes = new Dictionary + { + { EditType.Mix, new SubEditMode(DirectorStyles.kMixToolColor, KeyCode.Alpha1) }, + { EditType.Ripple, new SubEditMode(DirectorStyles.kRippleToolColor, KeyCode.Alpha2) }, + { EditType.Replace, new SubEditMode(DirectorStyles.kReplaceToolColor, KeyCode.Alpha3) } + }; + + static EditType s_CurrentEditType = EditType.Mix; + static EditType s_OverrideEditType = EditType.None; + + static ITrimmable s_CurrentTrimItem; + static TrimEdge s_CurrentTrimDirection; + static MoveItemHandler s_CurrentMoveItemHandler; + static EditModeInputHandler s_InputHandler = new EditModeInputHandler(); + + static ITrimItemMode trimMode + { + get { return GetSubEditMode(editType).trimItemMode; } + } + + static ITrimItemDrawer trimDrawer + { + get { return GetSubEditMode(editType).trimItemDrawer; } + } + + static IMoveItemMode moveMode + { + get { return GetSubEditMode(editType).moveItemMode; } + } + + static IMoveItemDrawer moveDrawer + { + get { return GetSubEditMode(editType).moveItemDrawer; } + } + + static IAddDeleteItemMode addDeleteMode + { + get { return GetSubEditMode(editType).addDeleteItemMode; } + } + + public static EditModeInputHandler inputHandler + { + get { return s_InputHandler; } + } + + static Color modeColor + { + get { return GetSubEditMode(editType).color; } + } + + public static EditType editType + { + get + { + if (s_OverrideEditType != EditType.None) + return s_OverrideEditType; + + var window = TimelineWindow.instance; + if (window != null) + s_CurrentEditType = window.state.editType; + + return s_CurrentEditType; + } + set + { + s_CurrentEditType = value; + + var window = TimelineWindow.instance; + if (window != null) + window.state.editType = value; + + s_OverrideEditType = EditType.None; + } + } + + static ISubEditMode GetSubEditMode(EditType type) + { + var subEditMode = k_EditModes[type]; + if (subEditMode != null) + return subEditMode; + + Debug.LogError("Unsupported editmode type"); + return null; + } + + static EditType GetSubEditType(KeyCode key) + { + foreach (var subEditMode in k_EditModes) + { + if (subEditMode.Value.clutchKey == key) + return subEditMode.Key; + } + return EditType.None; + } + + public static void ClearEditMode() + { + k_EditModes[editType].Reset(); + } + + public static void BeginTrim(ITimelineItem item, TrimEdge trimDirection) + { + var itemToTrim = item as ITrimmable; + if (itemToTrim == null) return; + + s_CurrentTrimItem = itemToTrim; + s_CurrentTrimDirection = trimDirection; + trimMode.OnBeforeTrim(itemToTrim, trimDirection); + UndoExtensions.RegisterTrack(itemToTrim.parentTrack, "Trim Clip"); + } + + public static void TrimStart(ITimelineItem item, double time, bool affectTimeScale) + { + var itemToTrim = item as ITrimmable; + if (itemToTrim == null) return; + + trimMode.TrimStart(itemToTrim, time, affectTimeScale); + } + + public static void TrimEnd(ITimelineItem item, double time, bool affectTimeScale) + { + var itemToTrim = item as ITrimmable; + if (itemToTrim == null) return; + + trimMode.TrimEnd(itemToTrim, time, affectTimeScale); + } + + public static void DrawTrimGUI(WindowState state, TimelineItemGUI item, TrimEdge edge) + { + trimDrawer.DrawGUI(state, item.rect, modeColor, edge); + } + + public static void FinishTrim() + { + s_CurrentTrimItem = null; + + TimelineCursors.ClearCursor(); + ClearEditMode(); + + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + public static void BeginMove(MoveItemHandler moveItemHandler) + { + s_CurrentMoveItemHandler = moveItemHandler; + moveMode.BeginMove(s_CurrentMoveItemHandler.movingItems); + } + + public static void UpdateMove() + { + moveMode.UpdateMove(s_CurrentMoveItemHandler.movingItems); + } + + public static void OnTrackDetach(IEnumerable grabbedTrackItems) + { + moveMode.OnTrackDetach(grabbedTrackItems); + } + + public static void HandleTrackSwitch(IEnumerable grabbedTrackItems) + { + moveMode.HandleTrackSwitch(grabbedTrackItems); + } + + public static bool AllowTrackSwitch() + { + return moveMode.AllowTrackSwitch(); + } + + public static double AdjustStartTime(WindowState state, ItemsPerTrack itemsGroup, double time) + { + return moveMode.AdjustStartTime(state, itemsGroup, time); + } + + public static bool ValidateDrag(ItemsPerTrack itemsGroup) + { + return moveMode.ValidateMove(itemsGroup); + } + + public static void DrawMoveGUI(WindowState state, IEnumerable movingItems) + { + moveDrawer.DrawGUI(state, movingItems, modeColor); + } + + public static void FinishMove() + { + var manipulatedItemsList = s_CurrentMoveItemHandler.movingItems; + moveMode.FinishMove(manipulatedItemsList); + + foreach (var itemsGroup in manipulatedItemsList) + foreach (var item in itemsGroup.items) + item.parentTrack = itemsGroup.targetTrack; + + s_CurrentMoveItemHandler = null; + + TimelineCursors.ClearCursor(); + ClearEditMode(); + + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + public static void FinalizeInsertItemsAtTime(IEnumerable newItems, double requestedTime) + { + addDeleteMode.InsertItemsAtTime(newItems, requestedTime); + } + + public static void PrepareItemsDelete(IEnumerable newItems) + { + addDeleteMode.RemoveItems(newItems); + } + + public static void HandleModeClutch() + { + if (Event.current.type == EventType.KeyDown && EditorGUI.IsEditingTextField()) + return; + + var prevType = editType; + + if (Event.current.type == EventType.KeyDown) + { + var clutchEditType = GetSubEditType(Event.current.keyCode); + if (clutchEditType != EditType.None) + { + s_OverrideEditType = clutchEditType; + Event.current.Use(); + } + } + else if (Event.current.type == EventType.KeyUp) + { + var clutchEditType = GetSubEditType(Event.current.keyCode); + if (clutchEditType == s_OverrideEditType) + { + s_OverrideEditType = EditType.None; + Event.current.Use(); + } + } + + if (prevType != editType) + { + if (s_CurrentTrimItem != null) + { + trimMode.OnBeforeTrim(s_CurrentTrimItem, s_CurrentTrimDirection); + } + else if (s_CurrentMoveItemHandler != null) + { + if (s_CurrentMoveItemHandler.movingItems == null) + { + s_CurrentMoveItemHandler = null; + return; + } + + foreach (var movingItems in s_CurrentMoveItemHandler.movingItems) + { + if (movingItems != null && movingItems.HasAnyDetachedParents()) + { + foreach (var items in movingItems.items) + { + items.parentTrack = movingItems.originalTrack; + } + } + } + + var movingSelection = s_CurrentMoveItemHandler.movingItems; + + // Handle clutch key transition if needed + GetSubEditMode(prevType).moveItemMode.OnModeClutchExit(movingSelection); + moveMode.OnModeClutchEnter(movingSelection); + + moveMode.BeginMove(movingSelection); + moveMode.HandleTrackSwitch(movingSelection); + + UpdateMove(); + s_CurrentMoveItemHandler.RefreshPreviewItems(); + + TimelineWindow.instance.state.rebuildGraph = true; // TODO Rebuild only if parent changed + } + + TimelineWindow.instance.Repaint(); // TODO Refresh the toolbar without doing a full repaint? + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/EditMode.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/EditMode.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..4ec42d4a80cefa53de14c8fba5dfaa6bc61cfbc9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/EditMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: dfd084fea478f3148b7de3d83bab1d8c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/EditModeInputHandler.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/EditModeInputHandler.cs new file mode 100644 index 0000000000000000000000000000000000000000..0c8a5d88b793710b3e36e2772faf669dbf5fdce0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/EditModeInputHandler.cs @@ -0,0 +1,199 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class EditModeInputHandler + { + readonly MoveInputHandler m_MoveHandler; + readonly TrimInputHandler m_TrimHandler; + + public EditModeInputHandler() + { + m_MoveHandler = new MoveInputHandler(); + m_TrimHandler = new TrimInputHandler(); + } + + public void ProcessMove(InputEvent action, double value) + { + if (TimelineWindow.instance != null && TimelineWindow.instance.state != null) + ProcessInputAction(m_MoveHandler, action, value, TimelineWindow.instance.state); + } + + public void ProcessTrim(InputEvent action, double value, bool stretch) + { + if (TimelineWindow.instance != null && TimelineWindow.instance.state != null) + { + m_TrimHandler.stretch = stretch; + ProcessInputAction(m_TrimHandler, action, value, TimelineWindow.instance.state); + } + } + + public void SetValueForEdge(IEnumerable items, AttractedEdge edge, double value) + { + if (TimelineWindow.instance != null && TimelineWindow.instance.state != null) + MoveInputHandler.SetValueForEdge(items, edge, value, TimelineWindow.instance.state); + } + + public void OnGUI(WindowState state, Event evt) + { + if (TimelineWindow.instance != null && TimelineWindow.instance.state != null) + { + m_MoveHandler.OnGUI(evt); + m_TrimHandler.OnGUI(state); + } + } + + static void ProcessInputAction(IInputHandler handler, InputEvent action, double value, WindowState state) + { + var items = SelectionManager.SelectedItems(); + switch (action) + { + case InputEvent.None: + return; + case InputEvent.DragEnter: + handler.OnEnterDrag(items, state); + break; + case InputEvent.Drag: + handler.OnDrag(value, state); + break; + case InputEvent.DragExit: + handler.OnExitDrag(); + break; + case InputEvent.KeyboardInput: + handler.OnSetValue(items, value, state); + break; + default: + return; + } + } + + interface IInputHandler + { + void OnEnterDrag(IEnumerable items, WindowState state); + void OnDrag(double value, WindowState state); + void OnExitDrag(); + void OnSetValue(IEnumerable items, double value, WindowState state); + } + + class TrimInputHandler : IInputHandler + { + bool isDragging { get; set; } + public bool stretch { get; set; } + + IEnumerable grabbedItems { get; set; } + + public void OnEnterDrag(IEnumerable items, WindowState state) + { + grabbedItems = items.OfType().ToArray(); + foreach (var item in grabbedItems) + { + EditMode.BeginTrim(item, TrimEdge.End); + } + + isDragging = true; + } + + public void OnDrag(double endValue, WindowState state) + { + var trimValue = endValue; + trimValue = TimeReferenceUtility.SnapToFrameIfRequired(trimValue); + + foreach (var item in grabbedItems) + { + EditMode.TrimEnd(item, trimValue, stretch); + } + state.UpdateRootPlayableDuration(state.editSequence.duration); + } + + public void OnExitDrag() + { + isDragging = false; + EditMode.FinishTrim(); + TimelineWindow.instance.Repaint(); + } + + public void OnSetValue(IEnumerable items, double endValue, WindowState state) + { + foreach (var item in items.OfType()) + { + EditMode.BeginTrim(item, TrimEdge.End); + EditMode.TrimEnd(item, endValue, stretch); + EditMode.FinishTrim(); + } + state.UpdateRootPlayableDuration(state.editSequence.duration); + } + + public void OnGUI(WindowState state) + { + if (!isDragging) return; + + foreach (var item in grabbedItems) + { + EditMode.DrawTrimGUI(state, item.gui, TrimEdge.End); + } + } + } + + class MoveInputHandler : IInputHandler + { + MoveItemHandler m_MoveItemHandler; + + public void OnEnterDrag(IEnumerable items, WindowState state) + { + if (items.Any()) + { + m_MoveItemHandler = new MoveItemHandler(state); + m_MoveItemHandler.Grab(items, items.First().parentTrack); + } + } + + public void OnDrag(double value, WindowState state) + { + if (m_MoveItemHandler == null) return; + + var startValue = value; + startValue = TimeReferenceUtility.SnapToFrameIfRequired(startValue); + m_MoveItemHandler.OnAttractedEdge(null, ManipulateEdges.Both, AttractedEdge.None, startValue); + } + + public void OnExitDrag() + { + if (m_MoveItemHandler == null) return; + + m_MoveItemHandler.Drop(); + m_MoveItemHandler = null; + GUIUtility.ExitGUI(); + } + + public void OnSetValue(IEnumerable items, double value, WindowState state) + { + if (!items.Any()) return; + + m_MoveItemHandler = new MoveItemHandler(state); + m_MoveItemHandler.Grab(items, items.First().parentTrack); + m_MoveItemHandler.OnAttractedEdge(null, ManipulateEdges.Both, AttractedEdge.None, value); + m_MoveItemHandler.Drop(); + m_MoveItemHandler = null; + } + + public void OnGUI(Event evt) + { + if (m_MoveItemHandler != null) + m_MoveItemHandler.OnGUI(evt); + } + + public static void SetValueForEdge(IEnumerable items, AttractedEdge edge, double value, WindowState state) + { + var handler = new MoveItemHandler(state); + foreach (var item in items) + { + handler.Grab(new[] {item}, item.parentTrack); + handler.OnAttractedEdge(null, ManipulateEdges.Both, edge, value); + handler.Drop(); + } + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/EditModeInputHandler.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/EditModeInputHandler.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..7ea2d6dcb4855e9e86763b9dfb460f3b89a9c531 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/EditModeInputHandler.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 459f6a07ee4a58b42ba2568b097c3ec4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Move.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Move.meta new file mode 100644 index 0000000000000000000000000000000000000000..b8648c3c307834f7988c7cebdc88a86174ba08b5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Move.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: bd3ffb9a97575a44a82f9ca086813154 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Sequence.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Sequence.meta new file mode 100644 index 0000000000000000000000000000000000000000..64e65bcd2c59e2e77706fd7e6fbb920b862573b4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Sequence.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: dec586c160776104da4d9a4e472662bc +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimeAreaAutoPanner.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimeAreaAutoPanner.cs new file mode 100644 index 0000000000000000000000000000000000000000..8052d653bb30a696c41751f2a8d866b4b6c0790c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimeAreaAutoPanner.cs @@ -0,0 +1,72 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class TimeAreaAutoPanner + { + readonly WindowState m_State; + readonly TimelineWindow m_Window; + readonly Rect m_ViewRect; + + const float k_PixelDistanceToMaxSpeed = 100.0f; + const float k_MaxPanSpeed = 30.0f; + + public TimeAreaAutoPanner(WindowState state) + { + m_State = state; + m_Window = m_State.GetWindow(); + + var shownRange = m_State.timeAreaShownRange; + var trackViewBounds = m_Window.sequenceRect; + m_ViewRect = Rect.MinMaxRect(m_State.TimeToPixel(shownRange.x), trackViewBounds.yMin, + m_State.TimeToPixel(shownRange.y), trackViewBounds.yMax); + } + + public void OnGUI(Event evt) + { + if (evt.type != EventType.Layout) + return; + + var hFactor = 0.0f; + var vFactor = 0.0f; + + bool horizontalPan = GetPanFactor(evt.mousePosition.x, m_ViewRect.xMin, m_ViewRect.xMax, out hFactor); + bool verticalPan = GetPanFactor(evt.mousePosition.y, m_ViewRect.yMin, m_ViewRect.yMax, out vFactor); + + if (horizontalPan) + { + var translation = m_State.timeAreaTranslation; + translation.x += hFactor * k_MaxPanSpeed; + + m_State.SetTimeAreaTransform(translation, m_State.timeAreaScale); + } + + if (verticalPan) + { + var translation = m_Window.treeView.scrollPosition; + translation.y -= vFactor * k_MaxPanSpeed; + + m_Window.treeView.scrollPosition = translation; + } + } + + static bool GetPanFactor(float v, float min, float max, out float factor) + { + factor = 0.0f; + + if (v < min) + { + factor = Mathf.Clamp01((min - v) / k_PixelDistanceToMaxSpeed); + return true; + } + + if (v > max) + { + factor = -Mathf.Clamp01((v - max) / k_PixelDistanceToMaxSpeed); + return true; + } + + return false; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimeAreaAutoPanner.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimeAreaAutoPanner.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..00a9eafb4fce04b9b17afd3b59613e0d51663d34 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimeAreaAutoPanner.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 02e1fe0a338b35545a5fed1345848332 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimeIndicator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimeIndicator.cs new file mode 100644 index 0000000000000000000000000000000000000000..d896ae5454c8521265a8005dda4e2abd7b9e6eac --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimeIndicator.cs @@ -0,0 +1,47 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + static class TimeIndicator + { + static readonly Tooltip s_Tooltip = new Tooltip(DirectorStyles.Instance.displayBackground, DirectorStyles.Instance.tinyFont); + + public static void Draw(WindowState state, double time) + { + var bounds = state.timeAreaRect; + bounds.xMin = Mathf.Max(bounds.xMin, state.TimeToTimeAreaPixel(time)); + + using (new GUIViewportScope(state.timeAreaRect)) + { + s_Tooltip.text = TimeReferenceUtility.ToTimeString(time); + + var tooltipBounds = s_Tooltip.bounds; + tooltipBounds.xMin = bounds.xMin - (tooltipBounds.width / 2.0f); + tooltipBounds.y = bounds.y; + s_Tooltip.bounds = tooltipBounds; + + if (time >= 0) + s_Tooltip.Draw(); + } + + if (time >= 0) + { + Graphics.DrawLineAtTime(state, time, Color.black, true); + } + } + + public static void Draw(WindowState state, double start, double end) + { + var bounds = state.timeAreaRect; + bounds.xMin = Mathf.Max(bounds.xMin, state.TimeToTimeAreaPixel(start)); + bounds.xMax = Mathf.Min(bounds.xMax, state.TimeToTimeAreaPixel(end)); + + var color = DirectorStyles.Instance.selectedStyle.focused.textColor; + color.a = 0.12f; + EditorGUI.DrawRect(bounds, color); + + Draw(state, start); + Draw(state, end); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimeIndicator.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimeIndicator.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..c8244f7d8894a83670c54c425f271cf0714375c0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimeIndicator.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1d446e57147ca9b4183edfbbfa9bf206 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimelineClipGroup.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimelineClipGroup.cs new file mode 100644 index 0000000000000000000000000000000000000000..03f4d8de41cb42fdd74249526097533c62ec3c67 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimelineClipGroup.cs @@ -0,0 +1,54 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TimelineClipGroup + { + readonly TimelineClip[] m_Clips; + readonly TimelineClip m_LeftMostClip; + readonly TimelineClip m_RightMostClip; + + public TimelineClip[] clips + { + get { return m_Clips; } + } + + public double start + { + get { return m_LeftMostClip.start; } + set + { + var offset = value - m_LeftMostClip.start; + + foreach (var clip in m_Clips) + clip.start += offset; + } + } + + public double end + { + get { return m_RightMostClip.end; } + } + + public TimelineClipGroup(IEnumerable clips) + { + Debug.Assert(clips != null && clips.Any()); + + m_Clips = clips.ToArray(); + m_LeftMostClip = null; + m_RightMostClip = null; + + foreach (var clip in m_Clips) + { + if (m_LeftMostClip == null || clip.start < m_LeftMostClip.start) + m_LeftMostClip = clip; + + if (m_RightMostClip == null || clip.end > m_RightMostClip.end) + m_RightMostClip = clip; + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimelineClipGroup.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimelineClipGroup.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..6106644efe54308e998ee18ec20e054b998393e9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/TimelineClipGroup.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b8c3bda3a988b5f4c910a5c3f722d0be +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Trim.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Trim.meta new file mode 100644 index 0000000000000000000000000000000000000000..e40400fc98dc64c2ea23a152d60f40e13a2c00dd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Trim.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: f6d64d8648793944dbadfd71f0f4b0a1 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Utils.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Utils.meta new file mode 100644 index 0000000000000000000000000000000000000000..b4af7ca654d9c6eb490a534f755bcbbb73fb4d5f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Utils.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 67e9c6cf60c57a54f9f4db1bc33fd2e3 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Playables/ControlPlayableInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Playables/ControlPlayableInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..5e6f07793a7cf31f854a6a3fce2b1de1e918df60 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Playables/ControlPlayableInspector.cs @@ -0,0 +1,212 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [CustomEditor(typeof(ControlPlayableAsset)), CanEditMultipleObjects] + class ControlPlayableInspector : Editor + { + static class Styles + { + static string s_DisabledBecauseOfSelfControlTooltip = "Must be disabled when the Source Game Object references the same PlayableDirector component that is being controlled"; + public static readonly GUIContent activationContent = EditorGUIUtility.TrTextContent("Control Activation", "When checked the clip will control the active state of the source game object"); + public static readonly GUIContent activationDisabledContent = EditorGUIUtility.TextContent("Control Activation|" + s_DisabledBecauseOfSelfControlTooltip); + public static readonly GUIContent prefabContent = EditorGUIUtility.TrTextContent("Prefab", "A prefab to instantiate as a child object of the source game object"); + public static readonly GUIContent advancedContent = EditorGUIUtility.TrTextContent("Advanced"); + public static readonly GUIContent updateParticleSystemsContent = EditorGUIUtility.TrTextContent("Control Particle Systems", "Synchronize the time between the clip and any particle systems on the game object"); + public static readonly GUIContent updatePlayableDirectorContent = EditorGUIUtility.TrTextContent("Control Playable Directors", "Synchronize the time between the clip and any playable directors on the game object"); + public static readonly GUIContent updatePlayableDirectorDisabledContent = EditorGUIUtility.TextContent("Control Playable Directors|" + s_DisabledBecauseOfSelfControlTooltip); + public static readonly GUIContent updateITimeControlContent = EditorGUIUtility.TrTextContent("Control ITimeControl", "Synchronize the time between the clip and any Script that implements the ITimeControl interface on the game object"); + public static readonly GUIContent updateHierarchy = EditorGUIUtility.TrTextContent("Control Children", "Search child game objects for particle systems and playable directors"); + public static readonly GUIContent randomSeedContent = EditorGUIUtility.TrTextContent("Random Seed", "A random seed to provide the particle systems for consistent previews. This will only be used on particle systems where AutoRandomSeed is on."); + public static readonly GUIContent postPlayableContent = EditorGUIUtility.TrTextContent("Post Playback", "The active state to the leave the game object when the timeline is finished. \n\nRevert will leave the game object in the state it was prior to the timeline being run"); + } + + SerializedProperty m_SourceObject; + SerializedProperty m_PrefabObject; + SerializedProperty m_UpdateParticle; + SerializedProperty m_UpdateDirector; + SerializedProperty m_UpdateITimeControl; + SerializedProperty m_SearchHierarchy; + SerializedProperty m_UseActivation; + SerializedProperty m_PostPlayback; + SerializedProperty m_RandomSeed; + bool m_CycleReference; + + + GUIContent m_SourceObjectLabel = new GUIContent(); + + // the director that the selection was made with. Normally this matches the active director in timeline, + // but persists if the active timeline changes (case 962516) + private PlayableDirector contextDirector + { + get + { + if (serializedObject == null) + return null; + return serializedObject.context as PlayableDirector; + } + } + + public void OnEnable() + { + if (target == null) // case 946080 + return; + + m_SourceObject = serializedObject.FindProperty("sourceGameObject"); + m_PrefabObject = serializedObject.FindProperty("prefabGameObject"); + + m_UpdateParticle = serializedObject.FindProperty("updateParticle"); + m_UpdateDirector = serializedObject.FindProperty("updateDirector"); + m_UpdateITimeControl = serializedObject.FindProperty("updateITimeControl"); + m_SearchHierarchy = serializedObject.FindProperty("searchHierarchy"); + m_UseActivation = serializedObject.FindProperty("active"); + m_PostPlayback = serializedObject.FindProperty("postPlayback"); + m_RandomSeed = serializedObject.FindProperty("particleRandomSeed"); + CheckForCyclicReference(); + } + + public override void OnInspectorGUI() + { + if (target == null) + return; + + serializedObject.Update(); + + m_SourceObjectLabel.text = m_SourceObject.displayName; + + if (m_PrefabObject.objectReferenceValue != null) + m_SourceObjectLabel.text = "Parent Object"; + + bool selfControlled = false; + + + EditorGUI.BeginChangeCheck(); + + using (new GUIMixedValueScope(m_SourceObject.hasMultipleDifferentValues)) + EditorGUILayout.PropertyField(m_SourceObject, m_SourceObjectLabel); + + var sourceGameObject = m_SourceObject.exposedReferenceValue as GameObject; + selfControlled = m_PrefabObject.objectReferenceValue == null && TimelineWindow.instance != null && TimelineWindow.instance.state != null && + contextDirector != null && sourceGameObject == contextDirector.gameObject; + + if (EditorGUI.EndChangeCheck()) + { + CheckForCyclicReference(); + if (!selfControlled) + DisablePlayOnAwake(sourceGameObject); + } + + if (selfControlled) + { + EditorGUILayout.HelpBox("The assigned GameObject references the same PlayableDirector component being controlled.", MessageType.Warning); + } + else if (m_CycleReference) + { + EditorGUILayout.HelpBox("The assigned GameObject contains a PlayableDirector component that results in a circular reference.", MessageType.Warning); + } + + EditorGUI.indentLevel++; + EditorGUILayout.PropertyField(m_PrefabObject, Styles.prefabContent); + EditorGUI.indentLevel--; + + using (new EditorGUI.DisabledScope(selfControlled)) + { + EditorGUILayout.PropertyField(m_UseActivation, selfControlled ? Styles.activationDisabledContent : Styles.activationContent); + if (m_UseActivation.boolValue) + { + EditorGUI.indentLevel++; + EditorGUILayout.PropertyField(m_PostPlayback, Styles.postPlayableContent); + EditorGUI.indentLevel--; + } + } + + m_SourceObject.isExpanded = EditorGUILayout.Foldout(m_SourceObject.isExpanded, Styles.advancedContent, true); + + if (m_SourceObject.isExpanded) + { + EditorGUI.indentLevel++; + + using (new EditorGUI.DisabledScope(selfControlled && !m_SearchHierarchy.boolValue)) + { + EditorGUI.BeginChangeCheck(); + EditorGUILayout.PropertyField(m_UpdateDirector, selfControlled ? Styles.updatePlayableDirectorDisabledContent : Styles.updatePlayableDirectorContent); + if (EditorGUI.EndChangeCheck()) + { + CheckForCyclicReference(); + } + } + + EditorGUILayout.PropertyField(m_UpdateParticle, Styles.updateParticleSystemsContent); + if (m_UpdateParticle.boolValue) + { + EditorGUI.indentLevel++; + EditorGUILayout.PropertyField(m_RandomSeed, Styles.randomSeedContent); + EditorGUI.indentLevel--; + } + EditorGUILayout.PropertyField(m_UpdateITimeControl, Styles.updateITimeControlContent); + + EditorGUILayout.PropertyField(m_SearchHierarchy, Styles.updateHierarchy); + + EditorGUI.indentLevel--; + } + + serializedObject.ApplyModifiedProperties(); + } + + // + // Fix for a workflow issue where scene objects with directors have play on awake by default enabled. + // This causes confusion when the director is played within another director, so we disable it on assignment + // to avoid the issue, but not force the issue on the user + public void DisablePlayOnAwake(GameObject sourceObject) + { + if (sourceObject != null && m_UpdateDirector.boolValue) + { + if (m_SearchHierarchy.boolValue) + { + var directors = sourceObject.GetComponentsInChildren(); + foreach (var d in directors) + { + DisablePlayOnAwake(d); + } + } + else + { + DisablePlayOnAwake(sourceObject.GetComponent()); + } + } + } + + public void DisablePlayOnAwake(PlayableDirector director) + { + if (director == null) + return; + var obj = new SerializedObject(director); + var prop = obj.FindProperty("m_InitialState"); + prop.enumValueIndex = (int)PlayState.Paused; + obj.ApplyModifiedProperties(); + } + + void CheckForCyclicReference() + { + serializedObject.ApplyModifiedProperties(); + m_CycleReference = false; + + PlayableDirector director = contextDirector; + if (contextDirector == null) + return; + + foreach (var asset in targets.OfType()) + { + if (ControlPlayableUtility.DetectCycle(asset, director)) + { + m_CycleReference = true; + return; + } + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Playables/ControlPlayableInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Playables/ControlPlayableInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a097e70e3bfb443272fc5c52bd073d7205add6c1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Playables/ControlPlayableInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f65646ef159c91441bff704a5f7f419b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Properties/AssemblyInfo.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000000000000000000000000000000000..31ab9739ad946b2f8c2050c6599fba03393c6296 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Properties/AssemblyInfo.cs @@ -0,0 +1,24 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("UnityEditor.Timeline")] +[assembly: AssemblyDescription("Unity Timeline Editor")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Unity Technologies")] +[assembly: AssemblyProduct("UnityEditor.Timeline")] +[assembly: AssemblyCopyright("Copyright © 2016")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[assembly: ComVisible(false)] +[assembly: Guid("7668179E-DE52-4D63-96C8-B7D84461EA29")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] +[assembly: InternalsVisibleTo("Assembly-CSharp-Editor-testable")] +[assembly: InternalsVisibleTo("Unity.Timeline.EditorTests")] +[assembly: InternalsVisibleTo("Unity.Timeline.Tests")] +[assembly: InternalsVisibleTo("Unity.Timeline.Tests.Common")] +[assembly: InternalsVisibleTo("Unity.Timeline.Tests.Performance.Editor")] diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Properties/AssemblyInfo.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Properties/AssemblyInfo.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..830ee0af9d3e269fe088cb375bb525120d5ef889 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Properties/AssemblyInfo.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d5718b3fe3a758b4a9ec29170290d4f6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/AnimationTrackRecorder.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/AnimationTrackRecorder.cs new file mode 100644 index 0000000000000000000000000000000000000000..abe3ed3c1621fb9287e6b74fe888ce617d11024f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/AnimationTrackRecorder.cs @@ -0,0 +1,306 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class AnimationTrackRecorder + { + public static readonly string kRecordClipDefaultName = L10n.Tr("Recorded"); + + AnimationClip m_TargetClip; + int m_CurveCount = 0; + + double m_ClipTime; + bool m_needRebuildRects; + + bool m_TrackHasPreviewComponents; + + public TimelineClip recordClip { get; private set; } + + public void PrepareForRecord(WindowState state) + { + m_CurveCount = 0; + m_TargetClip = null; + m_TrackHasPreviewComponents = false; + } + + public AnimationClip PrepareTrack(TrackAsset track, WindowState state, GameObject gameObject, out double startTime) + { + AnimationClip animationClip = null; + + // if we are not in clip mode, we simply use the track clip + var animationTrack = (AnimationTrack)track; + + // ignore recording if we are in Legacy auto mode + startTime = -1; + var parentTrack = TimelineUtility.GetSceneReferenceTrack(track) as AnimationTrack; + if (parentTrack != null && parentTrack.trackOffset == TrackOffset.Auto) + return null; + + if (!animationTrack.inClipMode) + { + var trackClip = animationTrack.GetOrCreateClip(); + startTime = trackClip.frameRate * state.editSequence.time; + + // Make the first key be at time 0 of the clip + if (trackClip.empty) + { + animationTrack.infiniteClipTimeOffset = 0; // state.time; + animationTrack.infiniteClipPreExtrapolation = TimelineClip.ClipExtrapolation.Hold; + animationTrack.infiniteClipPostExtrapolation = TimelineClip.ClipExtrapolation.Hold; + } + + animationClip = trackClip; + } + else + { + TimelineClip activeClip = null; + + // if it fails, but returns no clip, we can add one. + if (!track.FindRecordingClipAtTime(state.editSequence.time, out activeClip) && activeClip != null) + { + return null; + } + + if (activeClip == null) + { + activeClip = AddRecordableClip(track, state, state.editSequence.time); + } + + var clip = activeClip.animationClip; + + // flags this as the clip being recorded for the track + var clipTime = state.editSequence.time - activeClip.start; + + // if we are in the past + if (clipTime < 0) + { + Undo.RegisterCompleteObjectUndo(clip, "Record Key"); + UndoExtensions.RegisterTrack(track, "Prepend Key"); + ShiftAnimationClip(clip, (float)-clipTime); + activeClip.start = state.editSequence.time; + activeClip.duration += -clipTime; + clipTime = 0; + } + + m_ClipTime = clipTime; + recordClip = activeClip; + startTime = recordClip.ToLocalTimeUnbound(state.editSequence.time) * clip.frameRate; + m_needRebuildRects = clip.empty; + + animationClip = clip; + } + + m_TargetClip = animationClip; + m_CurveCount = GetCurveCount(animationClip); + m_TrackHasPreviewComponents = animationTrack.hasPreviewComponents; + + return animationClip; + } + + static int GetCurveCount(AnimationClip animationClip) + { + int count = 0; + if (animationClip != null) + { + var clipCache = AnimationClipCurveCache.Instance.GetCurveInfo(animationClip); + count = clipCache.curves.Length + clipCache.objectCurves.Count; + } + + return count; + } + + public void FinializeTrack(TrackAsset track, WindowState state) + { + // make sure we dirty the clip if we are in non clip mode + var animTrack = track as AnimationTrack; + if (!animTrack.inClipMode) + { + EditorUtility.SetDirty(animTrack.GetOrCreateClip()); + } + + // in clip mode we need to do some extra work + if (recordClip != null) + { + // stretch the clip out to meet the new recording time + if (m_ClipTime > recordClip.duration) + { + UndoExtensions.RegisterTrack(track, "Add Key"); + recordClip.duration = m_ClipTime; + } + + track.CalculateExtrapolationTimes(); + } + + recordClip = null; + m_ClipTime = 0; + if (m_needRebuildRects) + { + state.CalculateRowRects(); + m_needRebuildRects = false; + } + } + + public void FinalizeRecording(WindowState state) + { + // rebuild the graph if we add/remove a clip. Rebuild the graph with an evaluation immediately + // so previews and scene position is maintained. + if (m_CurveCount != GetCurveCount(m_TargetClip)) + { + state.rebuildGraph = true; + state.GetWindow().RebuildGraphIfNecessary(true); + } + else if (m_TrackHasPreviewComponents) + { + // Track with preview components potentially has modifications impacting other properties that need + // to be refreshed before inspector or scene view to not interfere with manipulation. + state.EvaluateImmediate(); + } + } + + // For a given track asset get a unique clip name + public static string GetUniqueRecordedClipName(Object owner, string name) + { + // first attempt -- uniquely named in file + var path = AssetDatabase.GetAssetPath(owner); + if (!string.IsNullOrEmpty(path)) + { + var names = AssetDatabase.LoadAllAssetsAtPath(path).Where(x => x != null).Select(x => x.name); + return ObjectNames.GetUniqueName(names.ToArray(), name); + } + + TrackAsset asset = owner as TrackAsset; + if (asset == null || asset.clips.Length == 0) + return name; + + // final attempt - uniquely named in track + return ObjectNames.GetUniqueName(asset.clips.Select(x => x.displayName).ToArray(), name); + } + + // Given an appropriate parent track, create a recordable clip + public static TimelineClip AddRecordableClip(TrackAsset parentTrack, WindowState state, double atTime) + { + var sequenceAsset = state.editSequence.asset; + if (sequenceAsset == null) + { + Debug.LogError("Parent Track needs to be bound to an asset to add a recordable"); + return null; + } + + var animTrack = parentTrack as AnimationTrack; + if (animTrack == null) + { + Debug.LogError("Recordable clips are only valid on Animation Tracks"); + return null; + } + + var newClip = animTrack.CreateRecordableClip(GetUniqueRecordedClipName(parentTrack, kRecordClipDefaultName)); + if (newClip == null) + { + Debug.LogError("Could not create a recordable clip"); + return null; + } + + newClip.mixInCurve = AnimationCurve.EaseInOut(0, 0, 1, 1); + newClip.mixOutCurve = AnimationCurve.EaseInOut(0, 1, 1, 0); + + newClip.preExtrapolationMode = TimelineClip.ClipExtrapolation.Hold; + newClip.postExtrapolationMode = TimelineClip.ClipExtrapolation.Hold; + + double startTime = 0; + double endTime = 0; + + GetAddedRecordingClipRange(animTrack, state, atTime, out startTime, out endTime); + + newClip.start = startTime; + newClip.duration = endTime - startTime; + + state.Refresh(); + + return newClip; + } + + // get the start and end times of what an added recording clip at a given time would be + internal static void GetAddedRecordingClipRange(TrackAsset track, WindowState state, double atTime, out double start, out double end) + { + // size to make the clip in pixels. Reasonably big so that both handles are easily manipulated, + // and the full title is normally visible + double defaultDuration = state.PixelDeltaToDeltaTime(100); + + start = atTime; + end = atTime + defaultDuration; + + double gapStart = 0; + double gapEnd = 0; + + // no gap, pick are reasonable amount + if (!track.GetGapAtTime(atTime, out gapStart, out gapEnd)) + { + start = atTime; + return; + } + + if (!double.IsInfinity(gapEnd)) + end = gapEnd; + + start = TimeReferenceUtility.SnapToFrameIfRequired(start); + end = TimeReferenceUtility.SnapToFrameIfRequired(end); + } + + // Given a clip, shifts the keys in that clip by the given amount. + internal static void ShiftAnimationClip(AnimationClip clip, float amount) + { + if (clip == null) + return; + + var curveBindings = AnimationUtility.GetCurveBindings(clip); + var objectCurveBindings = AnimationUtility.GetObjectReferenceCurveBindings(clip); + + foreach (var binding in curveBindings) + { + AnimationCurve curve = AnimationUtility.GetEditorCurve(clip, binding); + curve.keys = ShiftKeys(curve.keys, amount); + AnimationUtility.SetEditorCurve(clip, binding, curve); + } + + foreach (var binding in objectCurveBindings) + { + ObjectReferenceKeyframe[] keyframes = AnimationUtility.GetObjectReferenceCurve(clip, binding); + keyframes = ShiftObjectKeys(keyframes, amount); + AnimationUtility.SetObjectReferenceCurve(clip, binding, keyframes); + } + + EditorUtility.SetDirty(clip); + } + + // shift all the keys over by the given time, stretching the time 0 key + static Keyframe[] ShiftKeys(Keyframe[] keys, float time) + { + if (keys == null || keys.Length == 0 || time == 0) + return keys; + + for (int i = 0; i < keys.Length; i++) + { + keys[i].time += time; + } + + return keys; + } + + // Shift object keys over by the appropriate amount + static ObjectReferenceKeyframe[] ShiftObjectKeys(ObjectReferenceKeyframe[] keys, float time) + { + if (keys == null || keys.Length == 0 || time == 0) + return keys; + + for (int i = 0; i < keys.Length; i++) + { + keys[i].time += time; + } + + return keys; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/AnimationTrackRecorder.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/AnimationTrackRecorder.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e80ec10a4dc7d58c0c9926fe30fc1b999cc96365 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/AnimationTrackRecorder.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a0a02e768c802b641b6793fa864f1c2c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording.cs new file mode 100644 index 0000000000000000000000000000000000000000..6fc56e1bcb701a5bdad705493de8e9ba402f9add --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording.cs @@ -0,0 +1,499 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + // Handles Undo animated properties on Monobehaviours to create track clips + static partial class TimelineRecording + { + static readonly List s_TempPropertyModifications = new List(6); + + internal static UndoPropertyModification[] ProcessUndoModification(UndoPropertyModification[] modifications, WindowState state) + { + if (HasAnyPlayableAssetModifications(modifications)) + return ProcessPlayableAssetModification(modifications, state, false); + return ProcessMonoBehaviourModification(modifications, state); + } + + static UnityEngine.Object GetTarget(UndoPropertyModification undo) + { + if (undo.currentValue != null) + return undo.currentValue.target; + if (undo.previousValue != null) + return undo.previousValue.target; + return null; + } + + // Gets the appropriate track for a given game object + static TrackAsset GetTrackForGameObject(GameObject gameObject, WindowState state) + { + if (gameObject == null) + return null; + + var director = state.editSequence.director; + if (director == null) + return null; + + var level = int.MaxValue; + + TrackAsset result = null; + + // search the output tracks + var outputTracks = state.editSequence.asset.flattenedTracks; + foreach (var track in outputTracks) + { + if (track.GetType() != typeof(AnimationTrack)) + continue; + if (!state.IsTrackRecordable(track)) + continue; + + var obj = TimelineUtility.GetSceneGameObject(director, track); + if (obj != null) + { + // checks if the effected gameobject is our child + var childLevel = GetChildLevel(obj, gameObject); + if (childLevel != -1 && childLevel < level) + { + result = track; + level = childLevel; + } + } + } + + // the resulting track is not armed. checking here avoids accidentally recording objects with their own + // tracks + if (result && !state.IsTrackRecordable(result)) + { + result = null; + } + + return result; + } + + // Gets the track this property would record to. + // Returns null if there is a track, but it's not currently active for recording + public static TrackAsset GetRecordingTrack(SerializedProperty property, WindowState state) + { + var serializedObject = property.serializedObject; + var component = serializedObject.targetObject as Component; + if (component == null) + return null; + + var gameObject = component.gameObject; + return GetTrackForGameObject(gameObject, state); + } + + // Given a serialized property, gathers all animatable properties + static void GatherModifications(SerializedProperty property, List modifications) + { + // handles child properties (Vector3 is 3 recordable properties) + if (property.hasChildren) + { + var iter = property.Copy(); + var end = property.GetEndProperty(false); + + // recurse over all children properties + while (iter.Next(true) && !SerializedProperty.EqualContents(iter, end)) + { + GatherModifications(iter, modifications); + } + } + + var isObject = property.propertyType == SerializedPropertyType.ObjectReference; + var isFloat = property.propertyType == SerializedPropertyType.Float || + property.propertyType == SerializedPropertyType.Boolean || + property.propertyType == SerializedPropertyType.Integer; + + if (isObject || isFloat) + { + var serializedObject = property.serializedObject; + var modification = new PropertyModification(); + + modification.target = serializedObject.targetObject; + modification.propertyPath = property.propertyPath; + if (isObject) + { + modification.value = string.Empty; + modification.objectReference = property.objectReferenceValue; + } + else + { + modification.value = TimelineUtility.PropertyToString(property); + } + + // Path for monobehaviour based - better to grab the component to get the curvebinding to allow validation + if (serializedObject.targetObject is Component) + { + EditorCurveBinding temp; + var go = ((Component)serializedObject.targetObject).gameObject; + if (AnimationUtility.PropertyModificationToEditorCurveBinding(modification, go, out temp) != null) + { + modifications.Add(modification); + } + } + else + { + modifications.Add(modification); + } + } + } + + public static bool CanRecord(SerializedProperty property, WindowState state) + { + if (IsPlayableAssetProperty(property)) + return AnimatedParameterUtility.IsTypeAnimatable(property.propertyType); + + if (GetRecordingTrack(property, state) == null) + return false; + + s_TempPropertyModifications.Clear(); + GatherModifications(property, s_TempPropertyModifications); + return s_TempPropertyModifications.Any(); + } + + public static void AddKey(SerializedProperty prop, WindowState state) + { + s_TempPropertyModifications.Clear(); + GatherModifications(prop, s_TempPropertyModifications); + if (s_TempPropertyModifications.Any()) + { + AddKey(s_TempPropertyModifications, state); + } + } + + public static void AddKey(IEnumerable modifications, WindowState state) + { + var undos = modifications.Select(PropertyModificationToUndoPropertyModification).ToArray(); + if (HasAnyPlayableAssetModifications(undos)) + ProcessPlayableAssetModification(undos, state, true); + ProcessMonoBehaviourModification(undos, state); + } + + static UndoPropertyModification PropertyModificationToUndoPropertyModification(PropertyModification prop) + { + return new UndoPropertyModification + { + previousValue = prop, + currentValue = new PropertyModification + { + objectReference = prop.objectReference, + propertyPath = prop.propertyPath, + target = prop.target, + value = prop.value + }, + keepPrefabOverride = true + }; + } + + // Given an animation track, return the clip that we are currently recording to + static AnimationClip GetRecordingClip(TrackAsset asset, WindowState state, out double startTime, out double timeScale) + { + startTime = 0; + timeScale = 1; + + TimelineClip displayBackground = null; + asset.FindRecordingClipAtTime(state.editSequence.time, out displayBackground); + var animClip = asset.FindRecordingAnimationClipAtTime(state.editSequence.time); + + if (displayBackground != null) + { + startTime = displayBackground.start; + timeScale = displayBackground.timeScale; + } + + return animClip; + } + + // Helper that finds the animation clip we are recording and the relative time to that clip + static bool GetClipAndRelativeTime(UnityEngine.Object target, WindowState state, + out AnimationClip outClip, out double keyTime, out bool keyInRange) + { + const float floatToDoubleError = 0.00001f; + outClip = null; + keyTime = 0; + keyInRange = false; + + double startTime = 0; + double timeScale = 1; + AnimationClip clip = null; + + IPlayableAsset playableAsset = target as IPlayableAsset; + Component component = target as Component; + + // Handle recordable playable assets + if (playableAsset != null) + { + var curvesOwner = AnimatedParameterUtility.ToCurvesOwner(playableAsset, state.editSequence.asset); + if (curvesOwner != null) + { + if (curvesOwner.curves == null) + curvesOwner.CreateCurves(curvesOwner.GetUniqueRecordedClipName()); + + clip = curvesOwner.curves; + + var timelineClip = curvesOwner as TimelineClip; + if (timelineClip != null) + { + startTime = timelineClip.start; + timeScale = timelineClip.timeScale; + } + } + } + // Handle recording components, including infinite clip + else if (component != null) + { + var asset = GetTrackForGameObject(component.gameObject, state); + if (asset != null) + { + clip = GetRecordingClip(asset, state, out startTime, out timeScale); + } + } + + if (clip == null) + return false; + + keyTime = (state.editSequence.time - startTime) * timeScale; + outClip = clip; + keyInRange = keyTime >= 0 && keyTime <= (clip.length * timeScale + floatToDoubleError); + + return true; + } + + public static bool HasCurve(IEnumerable modifications, UnityEngine.Object target, + WindowState state) + { + return GetKeyTimes(target, modifications, state).Any(); + } + + public static bool HasKey(IEnumerable modifications, UnityEngine.Object target, + WindowState state) + { + AnimationClip clip; + double keyTime; + bool inRange; + if (!GetClipAndRelativeTime(target, state, out clip, out keyTime, out inRange)) + return false; + + return GetKeyTimes(target, modifications, state).Any(t => (CurveEditUtility.KeyCompare((float)state.editSequence.time, (float)t, clip.frameRate) == 0)); + } + + // Checks if a key already exists for this property + static bool HasBinding(UnityEngine.Object target, PropertyModification modification, AnimationClip clip, out EditorCurveBinding binding) + { + var component = target as Component; + var playableAsset = target as IPlayableAsset; + + if (component != null) + { + var type = AnimationUtility.PropertyModificationToEditorCurveBinding(modification, component.gameObject, out binding); + binding = RotationCurveInterpolation.RemapAnimationBindingForRotationCurves(binding, clip); + return type != null; + } + + if (playableAsset != null) + { + binding = EditorCurveBinding.FloatCurve(string.Empty, target.GetType(), + AnimatedParameterUtility.GetAnimatedParameterBindingName(target, modification.propertyPath)); + } + else + { + binding = new EditorCurveBinding(); + return false; + } + + return true; + } + + public static void RemoveKey(UnityEngine.Object target, IEnumerable modifications, + WindowState state) + { + AnimationClip clip; + double keyTime; + bool inRange; + if (!GetClipAndRelativeTime(target, state, out clip, out keyTime, out inRange) || !inRange) + return; + var refreshPreview = false; + TimelineUndo.PushUndo(clip, "Remove Key"); + foreach (var mod in modifications) + { + EditorCurveBinding temp; + if (HasBinding(target, mod, clip, out temp)) + { + if (temp.isPPtrCurve) + { + CurveEditUtility.RemoveObjectKey(clip, temp, keyTime); + if (CurveEditUtility.GetObjectKeyCount(clip, temp) == 0) + { + refreshPreview = true; + } + } + else + { + AnimationCurve curve = AnimationUtility.GetEditorCurve(clip, temp); + if (curve != null) + { + CurveEditUtility.RemoveKeyFrameFromCurve(curve, (float)keyTime, clip.frameRate); + AnimationUtility.SetEditorCurve(clip, temp, curve); + if (curve.length == 0) + { + AnimationUtility.SetEditorCurve(clip, temp, null); + refreshPreview = true; + } + } + } + } + } + + if (refreshPreview) + { + state.ResetPreviewMode(); + } + } + + static HashSet GetKeyTimes(UnityEngine.Object target, IEnumerable modifications, WindowState state) + { + var keyTimes = new HashSet(); + + AnimationClip animationClip; + double keyTime; + bool inRange; + GetClipAndRelativeTime(target, state, out animationClip, out keyTime, out inRange); + if (animationClip == null) + return keyTimes; + + var component = target as Component; + var playableAsset = target as IPlayableAsset; + var info = AnimationClipCurveCache.Instance.GetCurveInfo(animationClip); + + TimelineClip clip = null; + if (component != null) + { + GetTrackForGameObject(component.gameObject, state).FindRecordingClipAtTime(state.editSequence.time, out clip); + } + else if (playableAsset != null) + { + clip = FindClipWithAsset(state.editSequence.asset, playableAsset); + } + + foreach (var mod in modifications) + { + EditorCurveBinding temp; + if (HasBinding(target, mod, animationClip, out temp)) + { + IEnumerable keys = new HashSet(); + if (temp.isPPtrCurve) + { + var curve = info.GetObjectCurveForBinding(temp); + if (curve != null) + { + keys = curve.Select(x => (double)x.time); + } + } + else + { + var curve = info.GetCurveForBinding(temp); + if (curve != null) + { + keys = curve.keys.Select(x => (double)x.time); + } + } + + // Transform the times in to 'global' space using the clip + if (clip != null) + { + foreach (var k in keys) + { + var time = clip.FromLocalTimeUnbound(k); + const double eps = 1e-5; + if (time >= clip.start - eps && time <= clip.end + eps) + { + keyTimes.Add(time); + } + } + } + // infinite clip mode, global == local space + else + { + keyTimes.UnionWith(keys); + } + } + } + + return keyTimes; + } + + public static void NextKey(UnityEngine.Object target, IEnumerable modifications, WindowState state) + { + const double eps = 1e-5; + var keyTimes = GetKeyTimes(target, modifications, state); + if (keyTimes.Count == 0) + return; + var nextKeys = keyTimes.Where(x => x > state.editSequence.time + eps); + if (nextKeys.Any()) + { + state.editSequence.time = nextKeys.Min(); + } + } + + public static void PrevKey(UnityEngine.Object target, IEnumerable modifications, WindowState state) + { + const double eps = 1e-5; + var keyTimes = GetKeyTimes(target, modifications, state); + if (keyTimes.Count == 0) + return; + var prevKeys = keyTimes.Where(x => x < state.editSequence.time - eps); + if (prevKeys.Any()) + { + state.editSequence.time = prevKeys.Max(); + } + } + + public static void RemoveCurve(UnityEngine.Object target, IEnumerable modifications, WindowState state) + { + AnimationClip clip = null; + double keyTime = 0; + var inRange = false; // not used for curves + if (!GetClipAndRelativeTime(target, state, out clip, out keyTime, out inRange)) + return; + + TimelineUndo.PushUndo(clip, "Remove Curve"); + foreach (var mod in modifications) + { + EditorCurveBinding temp; + if (HasBinding(target, mod, clip, out temp)) + { + if (temp.isPPtrCurve) + AnimationUtility.SetObjectReferenceCurve(clip, temp, null); + else + AnimationUtility.SetEditorCurve(clip, temp, null); + } + } + + state.ResetPreviewMode(); + } + + public static IEnumerable GetRecordableGameObjects(WindowState state) + { + if (state == null || state.editSequence.asset == null || state.editSequence.director == null) + yield break; + + var outputTracks = state.editSequence.asset.GetOutputTracks(); + foreach (var track in outputTracks) + { + if (track.GetType() != typeof(AnimationTrack)) + continue; + if (!state.IsTrackRecordable(track) && !track.GetChildTracks().Any(state.IsTrackRecordable)) + continue; + + var obj = TimelineUtility.GetSceneGameObject(state.editSequence.director, track); + if (obj != null) + { + yield return obj; + } + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..d8bca18e54027462ac4d8f8acd68111f4db94333 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ef4c81c9368d5a340b14c2fec1cad345 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecordingContextualResponder.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecordingContextualResponder.cs new file mode 100644 index 0000000000000000000000000000000000000000..e55ff56268227f0807a3faa5298418529b651d5d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecordingContextualResponder.cs @@ -0,0 +1,134 @@ +using UnityEditorInternal; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TimelineRecordingContextualResponder : IAnimationContextualResponder + { + public WindowState state { get; internal set; } + + public TimelineRecordingContextualResponder(WindowState _state) + { + state = _state; + } + + //Unsupported stuff + public bool HasAnyCandidates() { return false; } + public bool HasAnyCurves() {return false; } + public void AddCandidateKeys() {} + public void AddAnimatedKeys() {} + + public bool IsAnimatable(PropertyModification[] modifications) + { + // search playable assets + for (int i = 0; i < modifications.Length; i++) + { + var iAsset = modifications[i].target as IPlayableAsset; + if (iAsset != null) + { + var curvesOwner = AnimatedParameterUtility.ToCurvesOwner(iAsset, state.editSequence.asset); + if (curvesOwner != null && curvesOwner.HasAnyAnimatableParameters() && curvesOwner.IsParameterAnimatable(modifications[i].propertyPath)) + return true; + } + } + + // search recordable game objects + foreach (var gameObject in TimelineRecording.GetRecordableGameObjects(state)) + { + for (int i = 0; i < modifications.Length; ++i) + { + var modification = modifications[i]; + if (AnimationWindowUtility.PropertyIsAnimatable(modification.target, modification.propertyPath, gameObject)) + return true; + } + } + + return false; + } + + public bool IsEditable(Object targetObject) + { + return true; // i.e. all animatable properties are editable + } + + public bool KeyExists(PropertyModification[] modifications) + { + if (modifications.Length == 0 || modifications[0].target == null) + return false; + + return TimelineRecording.HasKey(modifications, modifications[0].target, state); + } + + public bool CandidateExists(PropertyModification[] modifications) + { + return true; + } + + public bool CurveExists(PropertyModification[] modifications) + { + if (modifications.Length == 0 || modifications[0].target == null) + return false; + + return TimelineRecording.HasCurve(modifications, modifications[0].target, state); + } + + public void AddKey(PropertyModification[] modifications) + { + TimelineRecording.AddKey(modifications, state); + state.Refresh(); + } + + public void RemoveKey(PropertyModification[] modifications) + { + if (modifications.Length == 0) + return; + + var target = modifications[0].target; + if (target == null) + return; + + TimelineRecording.RemoveKey(modifications[0].target, modifications, state); + + var curvesOwner = target as ICurvesOwner; + if (curvesOwner != null) + curvesOwner.SanitizeCurvesData(); + + state.Refresh(); + } + + public void RemoveCurve(PropertyModification[] modifications) + { + if (modifications.Length == 0) + return; + + var target = modifications[0].target; + if (target == null) + return; + + TimelineRecording.RemoveCurve(target, modifications, state); + + var curvesOwner = target as ICurvesOwner; + if (curvesOwner != null) + curvesOwner.SanitizeCurvesData(); + + state.Refresh(); + } + + public void GoToNextKeyframe(PropertyModification[] modifications) + { + if (modifications.Length == 0 || modifications[0].target == null) + return; + + TimelineRecording.NextKey(modifications[0].target, modifications, state); + state.Refresh(); + } + + public void GoToPreviousKeyframe(PropertyModification[] modifications) + { + TimelineRecording.PrevKey(modifications[0].target, modifications, state); + state.Refresh(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecordingContextualResponder.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecordingContextualResponder.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2e8e492678969fa3c5bb6c50d0d4a76c74999e38 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecordingContextualResponder.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a59c2e62fbd97f84f92c3b546e3903cb +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording_Monobehaviour.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording_Monobehaviour.cs new file mode 100644 index 0000000000000000000000000000000000000000..715058d8f51d5538f423559fe0874673dcfe574a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording_Monobehaviour.cs @@ -0,0 +1,718 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEditorInternal; +using UnityEngine; +using UnityEngine.Timeline; +using System.Globalization; + +namespace UnityEditor.Timeline +{ + // Methods and data for handling recording to monobehaviours + static partial class TimelineRecording + { + internal class RecordingState : IAnimationRecordingState + { + public GameObject activeGameObject { get; set; } + public GameObject activeRootGameObject { get; set; } + public AnimationClip activeAnimationClip { get; set; } + + public void SaveCurve(AnimationWindowCurve curve) + { + Undo.RegisterCompleteObjectUndo(activeAnimationClip, "Edit Curve"); + AnimationWindowUtility.SaveCurve(activeAnimationClip, curve); + } + + public void AddPropertyModification(EditorCurveBinding binding, PropertyModification propertyModification, bool keepPrefabOverride) + { + AnimationMode.AddPropertyModification(binding, propertyModification, keepPrefabOverride); + } + + public bool addZeroFrame + { + get { return false; } + } + + public int currentFrame { get; set; } + + public bool DiscardModification(PropertyModification modification) + { + return false; + } + } + + static readonly RecordingState s_RecordState = new RecordingState(); + static readonly AnimationTrackRecorder s_TrackRecorder = new AnimationTrackRecorder(); + static readonly List s_UnprocessedMods = new List(); + static readonly List s_ModsToProcess = new List(); + static AnimationTrack s_LastTrackWarning; + + public const string kLocalPosition = "m_LocalPosition"; + public const string kLocalRotation = "m_LocalRotation"; + public const string kLocalEulerHint = "m_LocalEulerAnglesHint"; + const string kRotationWarning = "You are recording with an initial rotation offset. This may result in a misrepresentation of euler angles. When recording transform properties, it is recommended to reset rotation prior to recording"; + + + public static bool IsRecordingAnimationTrack { get; private set; } + + + internal static UndoPropertyModification[] ProcessMonoBehaviourModification(UndoPropertyModification[] modifications, WindowState state) + { + if (!state.recording) + return modifications; + + if (state == null || state.editSequence.director == null) + return modifications; + + s_UnprocessedMods.Clear(); + + s_TrackRecorder.PrepareForRecord(state); + + s_ModsToProcess.Clear(); + s_ModsToProcess.AddRange(modifications.Reverse()); + + while (s_ModsToProcess.Count > 0) + { + var modification = s_ModsToProcess[s_ModsToProcess.Count - 1]; + s_ModsToProcess.RemoveAt(s_ModsToProcess.Count - 1); + + // grab the clip we need to apply to + var modifiedGO = GetGameObjectFromModification(modification); + var track = GetTrackForGameObject(modifiedGO, state); + if (track != null) + { + IsRecordingAnimationTrack = true; + + double startTime = 0; + var clip = s_TrackRecorder.PrepareTrack(track, state, modifiedGO, out startTime); + if (clip == null) + { + s_ModsToProcess.Reverse(); + return s_ModsToProcess.ToArray(); + } + s_RecordState.activeAnimationClip = clip; + s_RecordState.activeRootGameObject = state.GetSceneReference(track); + s_RecordState.activeGameObject = modifiedGO; + s_RecordState.currentFrame = Mathf.RoundToInt((float)startTime); + + EditorUtility.SetDirty(clip); + var toProcess = GatherRelatedModifications(modification, s_ModsToProcess); + + var animator = s_RecordState.activeRootGameObject.GetComponent(); + var animTrack = track as AnimationTrack; + + // update preview mode before recording so the correct values get placed (in case we modify offsets) + // Case 900624 + UpdatePreviewMode(toProcess, modifiedGO); + + // if this is the first position/rotation recording, copy the current position / rotation to the track offset + AddTrackOffset(animTrack, toProcess, clip, animator); + + // same for clip mod clips being created + AddClipOffset(animTrack, toProcess, s_TrackRecorder.recordClip, animator); + + // Check if we need to handle position/rotation offsets + var handleOffsets = animator != null && modification.currentValue != null && + modification.currentValue.target == s_RecordState.activeRootGameObject.transform && + HasOffsets(animTrack, s_TrackRecorder.recordClip); + if (handleOffsets) + { + toProcess = HandleEulerModifications(animTrack, s_TrackRecorder.recordClip, clip, s_RecordState.currentFrame * clip.frameRate, toProcess); + RemoveOffsets(modification, animTrack, s_TrackRecorder.recordClip, toProcess); + } + + var remaining = AnimationRecording.Process(s_RecordState, toProcess); + if (remaining != null && remaining.Length != 0) + { + s_UnprocessedMods.AddRange(remaining); + } + + if (handleOffsets) + { + ReapplyOffsets(modification, animTrack, s_TrackRecorder.recordClip, toProcess); + } + + s_TrackRecorder.FinializeTrack(track, state); + + IsRecordingAnimationTrack = false; + } + else + { + s_UnprocessedMods.Add(modification); + } + } + + + s_TrackRecorder.FinalizeRecording(state); + + return s_UnprocessedMods.ToArray(); + } + + internal static bool IsPosition(UndoPropertyModification modification) + { + if (modification.currentValue != null) + return modification.currentValue.propertyPath.StartsWith(kLocalPosition); + else if (modification.previousValue != null) + return modification.previousValue.propertyPath.StartsWith(kLocalPosition); + return false; + } + + internal static bool IsRotation(UndoPropertyModification modification) + { + if (modification.currentValue != null) + return modification.currentValue.propertyPath.StartsWith(kLocalRotation) || + modification.currentValue.propertyPath.StartsWith(kLocalEulerHint); + if (modification.previousValue != null) + return modification.previousValue.propertyPath.StartsWith(kLocalRotation) || + modification.previousValue.propertyPath.StartsWith(kLocalEulerHint); + return false; + } + + // Test if this modification position or rotation + internal static bool IsPositionOrRotation(UndoPropertyModification modification) + { + return IsPosition(modification) || IsRotation(modification); + } + + internal static void UpdatePreviewMode(UndoPropertyModification[] mods, GameObject go) + { + if (mods.Any(x => IsPositionOrRotation(x) && IsRootModification(x))) + { + bool hasPosition = false; + bool hasRotation = false; + + foreach (var mod in mods) + { + EditorCurveBinding binding = new EditorCurveBinding(); + if (AnimationUtility.PropertyModificationToEditorCurveBinding(mod.previousValue, go, out binding) != null) + { + hasPosition |= IsPosition(mod); + hasRotation |= IsRotation(mod); + AnimationMode.AddPropertyModification(binding, mod.previousValue, true); + } + } + + // case 931859 - if we are only changing one field, all fields must be registered before + // any recording modifications + var driver = WindowState.previewDriver; + if (driver != null && AnimationMode.InAnimationMode(driver)) + { + if (hasPosition) + { + DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalPosition + ".x"); + DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalPosition + ".y"); + DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalPosition + ".z"); + } + else if (hasRotation) + { + DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalRotation + ".x"); + DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalRotation + ".y"); + DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalRotation + ".z"); + DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalRotation + ".w"); + } + } + } + } + + internal static bool IsRootModification(UndoPropertyModification modification) + { + string path = string.Empty; + if (modification.currentValue != null) + path = modification.currentValue.propertyPath; + else if (modification.previousValue != null) + path = modification.previousValue.propertyPath; + + return !path.Contains('/') && !path.Contains('\\'); + } + + // test if the clip has any position or rotation bindings + internal static bool ClipHasPositionOrRotation(AnimationClip clip) + { + if (clip == null || clip.empty) + return false; + + var info = AnimationClipCurveCache.Instance.GetCurveInfo(clip); + for (var i = 0; i < info.bindings.Length; i++) + { + bool isPositionOrRotation = + info.bindings[i].type != null && + typeof(Transform).IsAssignableFrom(info.bindings[i].type) && + ( + info.bindings[i].propertyName.StartsWith(kLocalPosition) || + info.bindings[i].propertyName.StartsWith(kLocalRotation) || + info.bindings[i].propertyName.StartsWith("localEuler") + ); + + if (isPositionOrRotation) + return true; + } + + return false; + } + + internal static TimelineAnimationUtilities.RigidTransform ComputeInitialClipOffsets(AnimationTrack track, UndoPropertyModification[] mods, Animator animator) + { + // take into account the track transform + var target = GetInitialTransform(mods, animator); + var trackToClip = TimelineAnimationUtilities.RigidTransform.identity; + if (track.trackOffset == TrackOffset.ApplyTransformOffsets) + trackToClip = TimelineAnimationUtilities.RigidTransform.Compose(track.position, track.rotation); + else if (track.trackOffset == TrackOffset.ApplySceneOffsets) + trackToClip = TimelineAnimationUtilities.RigidTransform.Compose(track.sceneOffsetPosition, Quaternion.Euler(track.sceneOffsetRotation)); + + target = TimelineAnimationUtilities.RigidTransform.Mul(TimelineAnimationUtilities.RigidTransform.Inverse(trackToClip), target); + + // set the previous position in case the animation system adds a default key + SetPreviousPositionAndRotation(mods, animator, trackToClip.position, trackToClip.rotation); + return target; + } + + internal static TimelineAnimationUtilities.RigidTransform GetInitialTransform(UndoPropertyModification[] mods, Animator animator) + { + var pos = Vector3.zero; + var rot = Quaternion.identity; + + // if we are operating on the root, grab the transform from the undo + if (mods[0].previousValue.target == animator.transform) + { + GetPreviousPositionAndRotation(mods, ref pos, ref rot); + } + // otherwise we need to grab it from the root object, which is the one with the actual animator + else + { + pos = animator.transform.localPosition; + rot = animator.transform.localRotation; + } + + // take into account the track transform + return TimelineAnimationUtilities.RigidTransform.Compose(pos, rot); + } + + internal static void SetPreviousPositionAndRotation(UndoPropertyModification[] mods, Animator animator, Vector3 pos, Quaternion rot) + { + if (mods[0].previousValue.target == animator.transform) + { + SetPreviousPositionAndRotation(mods, pos, rot); + } + } + + // If we are adding to an infinite clip, strip the objects position and rotation and set it as the clip offset + internal static void AddTrackOffset(AnimationTrack track, UndoPropertyModification[] mods, AnimationClip clip, Animator animator) + { + var copyTrackOffset = !track.inClipMode && + !ClipHasPositionOrRotation(clip) && + mods.Any(x => IsPositionOrRotation(x) && IsRootModification(x)) && + animator != null; + if (copyTrackOffset) + { + // in scene offset mode, makes sure we have the correct initial transform set + if (track.trackOffset == TrackOffset.ApplySceneOffsets) + { + var rigidTransform = GetInitialTransform(mods, animator); + track.sceneOffsetPosition = rigidTransform.position; + track.sceneOffsetRotation = rigidTransform.rotation.eulerAngles; + SetPreviousPositionAndRotation(mods, animator, rigidTransform.position, rigidTransform.rotation); + } + else + { + var rigidTransform = ComputeInitialClipOffsets(track, mods, animator); + track.infiniteClipOffsetPosition = rigidTransform.position; + track.infiniteClipOffsetEulerAngles = rigidTransform.rotation.eulerAngles; + } + } + } + + internal static void AddClipOffset(AnimationTrack track, UndoPropertyModification[] mods, TimelineClip clip, Animator animator) + { + if (clip == null || clip.asset == null) + return; + + var clipAsset = clip.asset as AnimationPlayableAsset; + var copyClipOffset = track.inClipMode && + clipAsset != null && !ClipHasPositionOrRotation(clipAsset.clip) && + mods.Any(x => IsPositionOrRotation(x) && IsRootModification(x)) && + animator != null; + if (copyClipOffset) + { + var rigidTransform = ComputeInitialClipOffsets(track, mods, animator); + + clipAsset.position = rigidTransform.position; + clipAsset.rotation = rigidTransform.rotation; + } + } + + internal static TimelineAnimationUtilities.RigidTransform GetLocalToTrack(AnimationTrack track, TimelineClip clip) + { + if (track == null) + return TimelineAnimationUtilities.RigidTransform.Compose(Vector3.zero, Quaternion.identity); + + var trackPos = track.position; + var trackRot = track.rotation; + + if (track.trackOffset == TrackOffset.ApplySceneOffsets) + { + trackPos = track.sceneOffsetPosition; + trackRot = Quaternion.Euler(track.sceneOffsetRotation); + } + + var clipWrapper = clip == null ? null : clip.asset as AnimationPlayableAsset; + var clipTransform = TimelineAnimationUtilities.RigidTransform.Compose(Vector3.zero, Quaternion.identity); + if (clipWrapper != null) + { + clipTransform = TimelineAnimationUtilities.RigidTransform.Compose(clipWrapper.position, clipWrapper.rotation); + } + else + { + clipTransform = TimelineAnimationUtilities.RigidTransform.Compose(track.infiniteClipOffsetPosition, track.infiniteClipOffsetRotation); + } + + var trackTransform = TimelineAnimationUtilities.RigidTransform.Compose(trackPos, trackRot); + + return TimelineAnimationUtilities.RigidTransform.Mul(trackTransform, clipTransform); + } + + // Checks whether there are any offsets applied to a clip + internal static bool HasOffsets(AnimationTrack track, TimelineClip clip) + { + if (track == null) + return false; + + bool hasClipOffsets = false; + bool hasTrackOffsets = false; + + var clipWrapper = clip == null ? null : clip.asset as AnimationPlayableAsset; + if (clipWrapper != null) + hasClipOffsets |= clipWrapper.position != Vector3.zero || clipWrapper.rotation != Quaternion.identity; + + if (track.trackOffset == TrackOffset.ApplySceneOffsets) + { + hasTrackOffsets = track.sceneOffsetPosition != Vector3.zero || track.sceneOffsetRotation != Vector3.zero; + } + else + { + hasTrackOffsets = (track.position != Vector3.zero || track.rotation != Quaternion.identity); + if (!track.inClipMode) + hasClipOffsets |= track.infiniteClipOffsetPosition != Vector3.zero || track.infiniteClipOffsetRotation != Quaternion.identity; + } + + return hasTrackOffsets || hasClipOffsets; + } + + internal static void RemoveOffsets(UndoPropertyModification modification, AnimationTrack track, TimelineClip clip, UndoPropertyModification[] mods) + { + if (IsPositionOrRotation(modification)) + { + var modifiedGO = GetGameObjectFromModification(modification); + var target = TimelineAnimationUtilities.RigidTransform.Compose(modifiedGO.transform.localPosition, modifiedGO.transform.localRotation); + var localToTrack = GetLocalToTrack(track, clip); + var trackToLocal = TimelineAnimationUtilities.RigidTransform.Inverse(localToTrack); + var localSpace = TimelineAnimationUtilities.RigidTransform.Mul(trackToLocal, target); + + // Update the undo call values + var prevPos = modifiedGO.transform.localPosition; + var prevRot = modifiedGO.transform.localRotation; + GetPreviousPositionAndRotation(mods, ref prevPos, ref prevRot); + var previousRigidTransform = TimelineAnimationUtilities.RigidTransform.Mul(trackToLocal, TimelineAnimationUtilities.RigidTransform.Compose(prevPos, prevRot)); + SetPreviousPositionAndRotation(mods, previousRigidTransform.position, previousRigidTransform.rotation); + + var currentPos = modifiedGO.transform.localPosition; + var currentRot = modifiedGO.transform.localRotation; + GetCurrentPositionAndRotation(mods, ref currentPos, ref currentRot); + var currentRigidTransform = TimelineAnimationUtilities.RigidTransform.Mul(trackToLocal, TimelineAnimationUtilities.RigidTransform.Compose(currentPos, currentRot)); + SetCurrentPositionAndRotation(mods, currentRigidTransform.position, currentRigidTransform.rotation); + + modifiedGO.transform.localPosition = localSpace.position; + modifiedGO.transform.localRotation = localSpace.rotation; + } + } + + internal static void ReapplyOffsets(UndoPropertyModification modification, AnimationTrack track, TimelineClip clip, UndoPropertyModification[] mods) + { + if (IsPositionOrRotation(modification)) + { + var modifiedGO = GetGameObjectFromModification(modification); + var target = TimelineAnimationUtilities.RigidTransform.Compose(modifiedGO.transform.localPosition, modifiedGO.transform.localRotation); + var localToTrack = GetLocalToTrack(track, clip); + var trackSpace = TimelineAnimationUtilities.RigidTransform.Mul(localToTrack, target); + + // Update the undo call values + var prevPos = modifiedGO.transform.localPosition; + var prevRot = modifiedGO.transform.localRotation; + GetPreviousPositionAndRotation(mods, ref prevPos, ref prevRot); + var previousRigidTransform = TimelineAnimationUtilities.RigidTransform.Mul(localToTrack, TimelineAnimationUtilities.RigidTransform.Compose(prevPos, prevRot)); + SetPreviousPositionAndRotation(mods, previousRigidTransform.position, previousRigidTransform.rotation); + + var currentPos = modifiedGO.transform.localPosition; + var currentRot = modifiedGO.transform.localRotation; + GetCurrentPositionAndRotation(mods, ref currentPos, ref currentRot); + var currentRigidTransform = TimelineAnimationUtilities.RigidTransform.Mul(localToTrack, TimelineAnimationUtilities.RigidTransform.Compose(currentPos, currentRot)); + SetCurrentPositionAndRotation(mods, currentRigidTransform.position, currentRigidTransform.rotation); + + modifiedGO.transform.localPosition = trackSpace.position; + modifiedGO.transform.localRotation = trackSpace.rotation; + } + } + + // This will gather the modifications that modify the same property on the same object (rgba of a color, xyzw of a vector) + // Note: This will modify the list, removing any elements that match + static UndoPropertyModification[] GatherRelatedModifications(UndoPropertyModification toMatch, List list) + { + var matching = new List {toMatch}; + + for (var i = list.Count - 1; i >= 0; i--) + { + var undo = list[i]; + if (undo.previousValue.target == toMatch.previousValue.target && + DoesPropertyPathMatch(undo.previousValue.propertyPath, toMatch.previousValue.propertyPath)) + { + matching.Add(undo); + list.RemoveAt(i); + } + } + + return matching.ToArray(); + } + + // Grab the game object out of the modification object + static GameObject GetGameObjectFromModification(UndoPropertyModification mod) + { + // grab the GO this is modifying + GameObject modifiedGO = null; + if (mod.previousValue.target is GameObject) + modifiedGO = mod.previousValue.target as GameObject; + else if (mod.previousValue.target is Component) + modifiedGO = (mod.previousValue.target as Component).gameObject; + + return modifiedGO; + } + + // returns the level of the child in the hierarchy relative to the parent, + // or -1 if the child is not the parent or a descendent of it + static int GetChildLevel(GameObject parent, GameObject child) + { + var level = 0; + while (child != null) + { + if (parent == child) + break; + if (child.transform.parent == null) + return -1; + child = child.transform.parent.gameObject; + level++; + } + + if (child != null) + return level; + return -1; + } + + static bool IsRotationCurve(string propertyName) + { + string groupName = AnimationWindowUtility.GetPropertyGroupName(propertyName); + return groupName == kLocalRotation || groupName == kLocalEulerHint; + } + + public static bool DoesPropertyPathMatch(string a, string b) + { + return AnimationWindowUtility.GetPropertyGroupName(a).Equals(AnimationWindowUtility.GetPropertyGroupName(b)) || IsRotationCurve(a) && IsRotationCurve(b); + } + + internal static void GetPreviousPositionAndRotation(UndoPropertyModification[] mods, ref Vector3 position, ref Quaternion rotation) + { + var t = mods[0].previousValue.target as Transform; + if (t == null) + t = (Transform)mods[0].currentValue.target; + + position = t.localPosition; + rotation = t.localRotation; + + foreach (var mod in mods) + { + switch (mod.previousValue.propertyPath) + { + case kLocalPosition + ".x": + position.x = ParseFloat(mod.previousValue.value, position.x); + break; + case kLocalPosition + ".y": + position.y = ParseFloat(mod.previousValue.value, position.y); + break; + case kLocalPosition + ".z": + position.z = ParseFloat(mod.previousValue.value, position.z); + break; + case kLocalRotation + ".x": + rotation.x = ParseFloat(mod.previousValue.value, rotation.x); + break; + case kLocalRotation + ".y": + rotation.y = ParseFloat(mod.previousValue.value, rotation.y); + break; + case kLocalRotation + ".z": + rotation.z = ParseFloat(mod.previousValue.value, rotation.z); + break; + case kLocalRotation + ".w": + rotation.w = ParseFloat(mod.previousValue.value, rotation.w); + break; + } + } + } + + internal static void GetCurrentPositionAndRotation(UndoPropertyModification[] mods, ref Vector3 position, ref Quaternion rotation) + { + var t = (Transform)mods[0].currentValue.target; + position = t.localPosition; + rotation = t.localRotation; + + foreach (var mod in mods) + { + switch (mod.currentValue.propertyPath) + { + case kLocalPosition + ".x": + position.x = ParseFloat(mod.currentValue.value, position.x); + break; + case kLocalPosition + ".y": + position.y = ParseFloat(mod.currentValue.value, position.y); + break; + case kLocalPosition + ".z": + position.z = ParseFloat(mod.currentValue.value, position.z); + break; + case kLocalRotation + ".x": + rotation.x = ParseFloat(mod.currentValue.value, rotation.x); + break; + case kLocalRotation + ".y": + rotation.y = ParseFloat(mod.currentValue.value, rotation.y); + break; + case kLocalRotation + ".z": + rotation.z = ParseFloat(mod.currentValue.value, rotation.z); + break; + case kLocalRotation + ".w": + rotation.w = ParseFloat(mod.currentValue.value, rotation.w); + break; + } + } + } + + // when making the previous position and rotation + internal static void SetPreviousPositionAndRotation(UndoPropertyModification[] mods, Vector3 pos, Quaternion rot) + { + foreach (var mod in mods) + { + switch (mod.previousValue.propertyPath) + { + case kLocalPosition + ".x": + mod.previousValue.value = pos.x.ToString(EditorGUI.kFloatFieldFormatString); + break; + case kLocalPosition + ".y": + mod.previousValue.value = pos.y.ToString(EditorGUI.kFloatFieldFormatString); + break; + case kLocalPosition + ".z": + mod.previousValue.value = pos.z.ToString(EditorGUI.kFloatFieldFormatString); + break; + case kLocalRotation + ".x": + mod.previousValue.value = rot.x.ToString(EditorGUI.kFloatFieldFormatString); + break; + case kLocalRotation + ".y": + mod.previousValue.value = rot.y.ToString(EditorGUI.kFloatFieldFormatString); + break; + case kLocalRotation + ".z": + mod.previousValue.value = rot.z.ToString(EditorGUI.kFloatFieldFormatString); + break; + case kLocalRotation + ".w": + mod.previousValue.value = rot.w.ToString(EditorGUI.kFloatFieldFormatString); + break; + } + } + } + + internal static void SetCurrentPositionAndRotation(UndoPropertyModification[] mods, Vector3 pos, Quaternion rot) + { + foreach (var mod in mods) + { + switch (mod.previousValue.propertyPath) + { + case kLocalPosition + ".x": + mod.currentValue.value = pos.x.ToString(EditorGUI.kFloatFieldFormatString); + break; + case kLocalPosition + ".y": + mod.currentValue.value = pos.y.ToString(EditorGUI.kFloatFieldFormatString); + break; + case kLocalPosition + ".z": + mod.currentValue.value = pos.z.ToString(EditorGUI.kFloatFieldFormatString); + break; + case kLocalRotation + ".x": + mod.currentValue.value = rot.x.ToString(EditorGUI.kFloatFieldFormatString); + break; + case kLocalRotation + ".y": + mod.currentValue.value = rot.y.ToString(EditorGUI.kFloatFieldFormatString); + break; + case kLocalRotation + ".z": + mod.currentValue.value = rot.z.ToString(EditorGUI.kFloatFieldFormatString); + break; + case kLocalRotation + ".w": + mod.currentValue.value = rot.w.ToString(EditorGUI.kFloatFieldFormatString); + break; + } + } + } + + internal static float ParseFloat(string str, float defaultVal) + { + float temp = 0.0f; + if (float.TryParse(str, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out temp)) + return temp; + return defaultVal; + } + + internal static UndoPropertyModification[] HandleEulerModifications(AnimationTrack track, TimelineClip clip, AnimationClip animClip, float time, UndoPropertyModification[] mods) + { + if (mods.Any(x => x.currentValue.propertyPath.StartsWith(kLocalEulerHint) || x.currentValue.propertyPath.StartsWith(kLocalRotation))) + { + // if there is a rotational offsets, we need to strip the euler hints, since they are used by the animation recording system + // over the quaternion. + var localToTrack = GetLocalToTrack(track, clip); + if (localToTrack.rotation != Quaternion.identity) + { + if (s_LastTrackWarning != track) + { + s_LastTrackWarning = track; + Debug.LogWarning(kRotationWarning); + } + + Transform transform = mods[0].currentValue.target as Transform; + if (transform != null) + { + var trackToLocal = TimelineAnimationUtilities.RigidTransform.Inverse(localToTrack); + // since the euler angles are going to be transformed, we do a best guess at a euler that gives the shortest path + var quatMods = mods.Where(x => !x.currentValue.propertyPath.StartsWith(kLocalEulerHint)); + var eulerMods = FindBestEulerHint(trackToLocal.rotation * transform.localRotation, animClip, time, transform); + return quatMods.Union(eulerMods).ToArray(); + } + return mods.Where(x => !x.currentValue.propertyPath.StartsWith(kLocalEulerHint)).ToArray(); + } + } + return mods; + } + + internal static IEnumerable FindBestEulerHint(Quaternion rotation, AnimationClip clip, float time, Transform transform) + { + Vector3 euler = rotation.eulerAngles; + + var xCurve = AnimationUtility.GetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "localEulerAnglesRaw.x")); + var yCurve = AnimationUtility.GetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "localEulerAnglesRaw.y")); + var zCurve = AnimationUtility.GetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "localEulerAnglesRaw.z")); + + if (xCurve != null) + euler.x = xCurve.Evaluate(time); + if (yCurve != null) + euler.y = yCurve.Evaluate(time); + if (zCurve != null) + euler.z = zCurve.Evaluate(time); + + euler = QuaternionCurveTangentCalculation.GetEulerFromQuaternion(rotation, euler); + + return new[] + { + PropertyModificationToUndoPropertyModification(new PropertyModification {target = transform, propertyPath = kLocalEulerHint + ".x", value = euler.x.ToString() }), + PropertyModificationToUndoPropertyModification(new PropertyModification {target = transform, propertyPath = kLocalEulerHint + ".y", value = euler.y.ToString() }), + PropertyModificationToUndoPropertyModification(new PropertyModification {target = transform, propertyPath = kLocalEulerHint + ".z", value = euler.z.ToString() }) + }; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording_Monobehaviour.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording_Monobehaviour.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..346e5bd985c6755d4a5f2192ce692c6a681c9efc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording_Monobehaviour.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9805855c8e379ed4cad77f639aaddb73 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording_PlayableAsset.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording_PlayableAsset.cs new file mode 100644 index 0000000000000000000000000000000000000000..0e6b59955aa6b79b1cf99d6862886c44662bc4ac --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording_PlayableAsset.cs @@ -0,0 +1,119 @@ +using System.Collections.Generic; +using System.Globalization; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + // Handles Undo animated properties on PlayableAssets from clips to create parameter animation + + static partial class TimelineRecording + { + internal static bool HasAnyPlayableAssetModifications(UndoPropertyModification[] modifications) + { + return modifications.Any(x => GetTarget(x) as IPlayableAsset != null); + } + + internal static UndoPropertyModification[] ProcessPlayableAssetModification(UndoPropertyModification[] modifications, WindowState state, bool allowAdd) + { + // can't record without a director since the asset being modified might be a scene instance + if (state == null || state.editSequence.director == null) + return modifications; + + var remaining = new List(); + foreach (UndoPropertyModification mod in modifications) + { + if (!ProcessPlayableAssetModification(mod, state, allowAdd)) + remaining.Add(mod); + } + + if (remaining.Count != modifications.Length) + { + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + return remaining.ToArray(); + } + + static bool ProcessPlayableAssetModification(UndoPropertyModification mod, WindowState state, bool allowAdd) + { + var target = GetTarget(mod) as IPlayableAsset; + if (target == null) + return false; + + var curvesOwner = AnimatedParameterUtility.ToCurvesOwner(target, state.editSequence.asset); + if (curvesOwner == null || !curvesOwner.HasAnyAnimatableParameters()) + return false; + + return ProcessPlayableAssetRecording(mod, state, curvesOwner, allowAdd); + } + + internal static TimelineClip FindClipWithAsset(TimelineAsset asset, IPlayableAsset target) + { + if (target == null || asset == null) + return null; + + var clips = asset.flattenedTracks.SelectMany(x => x.clips); + return clips.FirstOrDefault(x => x != null && x.asset != null && target == x.asset as IPlayableAsset); + } + + static bool ProcessPlayableAssetRecording(UndoPropertyModification mod, WindowState state, ICurvesOwner curvesOwner, bool allowAdd) + { + if (mod.currentValue == null) + return false; + + if (!curvesOwner.IsParameterAnimatable(mod.currentValue.propertyPath)) + return false; + + // only animate items with existing curves + if (!allowAdd && !curvesOwner.IsParameterAnimated(mod.currentValue.propertyPath)) + return false; + + var localTime = state.editSequence.time; + var timelineClip = curvesOwner as TimelineClip; + if (timelineClip != null) + { + // don't use time global to local since it will possibly loop. + localTime = timelineClip.ToLocalTimeUnbound(state.editSequence.time); + } + + if (localTime < 0) + return false; + + // grab the value from the current modification + float fValue; + if (!ExpressionEvaluator.Evaluate(mod.currentValue.value, out fValue)) + { + // case 916913 -- 'Add Key' menu item will passes 'True' or 'False' (instead of 1, 0) + // so we need a special case to parse the boolean string + bool bValue; + if (!bool.TryParse(mod.currentValue.value, out bValue)) + { + Debug.Assert(false, "Invalid type in PlayableAsset recording"); + return false; + } + + fValue = bValue ? 1 : 0; + } + + var added = curvesOwner.AddAnimatedParameterValueAt(mod.currentValue.propertyPath, fValue, (float)localTime); + if (added && AnimationMode.InAnimationMode()) + { + EditorCurveBinding binding = curvesOwner.GetCurveBinding(mod.previousValue.propertyPath); + AnimationMode.AddPropertyModification(binding, mod.previousValue, true); + curvesOwner.targetTrack.SetShowInlineCurves(true); + if (state.GetWindow() != null && state.GetWindow().treeView != null) + state.GetWindow().treeView.CalculateRowRects(); + } + + return added; + } + + static bool IsPlayableAssetProperty(SerializedProperty property) + { + return property.serializedObject.targetObject is IPlayableAsset; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording_PlayableAsset.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording_PlayableAsset.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e78220dc7c2304499e7227a9b69593e11cd51bdc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TimelineRecording_PlayableAsset.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 7341c0cd0aad4994e8fa461cb443aa7d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TrackAssetRecordingExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TrackAssetRecordingExtensions.cs new file mode 100644 index 0000000000000000000000000000000000000000..f44b82b2547dc71349aac0eff6dde8cb9deee8bb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TrackAssetRecordingExtensions.cs @@ -0,0 +1,191 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class TrackAssetRecordingExtensions + { + static readonly Dictionary s_ActiveClips = new Dictionary(); + + internal static void OnRecordingArmed(this TrackAsset track, PlayableDirector director) + { + if (track == null) + return; + + var animClip = track.FindRecordingAnimationClipAtTime(director.time); + if (animClip == null) + return; + + s_ActiveClips[track] = animClip; + } + + internal static void OnRecordingTimeChanged(this TrackAsset track, PlayableDirector director) + { + if (track == null) + return; + + var animClip = track.FindRecordingAnimationClipAtTime(director.time); + AnimationClip prevClip = track.GetActiveRecordingAnimationClip(); + if (prevClip != animClip) + { + s_ActiveClips[track] = animClip; + } + } + + internal static void OnRecordingUnarmed(this TrackAsset track, PlayableDirector director) + { + s_ActiveClips.Remove(track); + } + + internal static bool CanRecordAtTime(this TrackAsset track, double time) + { + // Animation Track + var animTrack = track as AnimationTrack; + if (animTrack != null) + { + if (!animTrack.inClipMode) + return true; + + TimelineClip clip = null; + return FindRecordingClipAtTime(track, time, out clip); + } + + // Custom track + return track.clips.Any(x => x.start < time + TimeUtility.kTimeEpsilon && x.HasAnyAnimatableParameters()); + } + + internal static AnimationClip GetActiveRecordingAnimationClip(this TrackAsset track) + { + AnimationClip clip = null; + s_ActiveClips.TryGetValue(track, out clip); + return clip; + } + + internal static bool IsRecordingToClip(this TrackAsset track, TimelineClip clip) + { + if (track == null || clip == null) + return false; + var animClip = track.GetActiveRecordingAnimationClip(); + if (animClip == null) + return false; + if (animClip == clip.curves) + return true; + + var animAsset = clip.asset as AnimationPlayableAsset; + return animAsset != null && animClip == animAsset.clip; + } + + // Finds the clip at the given time that recording should use + // returns whether recording at this particular point is valid + // The target clip will be returned, even if recording at that time is invalid + // in case of recording in a blend OR recording to a non-timeline clip + internal static bool FindRecordingClipAtTime(this TrackAsset track, double time, out TimelineClip target) + { + target = null; + if (track == null) + { + return false; + } + + var discreteTime = new DiscreteTime(time); + + // only animation tracks require the recordable flag as they are recording + // to an animation clip + bool requiresRecordable = (track as AnimationTrack) != null; + if (requiresRecordable) + { + track.SortClips(); + var sortedByStartTime = track.clips; + int i = 0; + for (i = 0; i < sortedByStartTime.Length; i++) + { + var clip = sortedByStartTime[i]; + if (new DiscreteTime(clip.start) <= discreteTime && new DiscreteTime(clip.end) > discreteTime) + { + target = clip; + // not recordable + if (!clip.recordable) + return false; + + // in a blend + if (!Mathf.Approximately(1.0f, clip.EvaluateMixIn(time) * clip.EvaluateMixOut(time))) + return false; + + return true; + } + + if (new DiscreteTime(clip.start) > discreteTime) + { + break; + } + } + + return false; + } + + + // Recordable playable assets -- takes the last clip that matches + track.SortClips(); + for (int i = 0; i < track.clips.Length; i++) + { + var clip = track.clips[i]; + if (clip.start <= time && clip.end >= time && clip.HasAnyAnimatableParameters()) + target = clip; + + if (clip.start > time) + break; + } + + return target != null; + } + + // 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; + } + + internal static void ClearRecordingState() + { + s_ActiveClips.Clear(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TrackAssetRecordingExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TrackAssetRecordingExtensions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..edbe4da9fbce8a4da6abb0ce2c7b221dd52f0f8c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Recording/TrackAssetRecordingExtensions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 49f1d2c7420db4444b011955726d0046 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalAssetInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalAssetInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..1c8c6f93e4deaba1aed0dc9ba91b7315371e668f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalAssetInspector.cs @@ -0,0 +1,28 @@ +using JetBrains.Annotations; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Signals +{ + [CustomEditor(typeof(SignalAsset))] + class SignalAssetInspector : Editor + { + [MenuItem("Assets/Create/Signal", false, 451)] + [UsedImplicitly] + public static void CreateNewSignal() + { + var icon = EditorGUIUtility.IconContent("SignalAsset Icon").image as Texture2D; + ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, CreateInstance(), "New Signal.signal", icon, null); + } + + class DoCreateSignalAsset : ProjectWindowCallback.EndNameEditAction + { + public override void Action(int instanceId, string pathName, string resourceFile) + { + var signalAsset = CreateInstance(); + AssetDatabase.CreateAsset(signalAsset, pathName); + ProjectWindowUtil.ShowCreatedAsset(signalAsset); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalAssetInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalAssetInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a135f38f2728f814943397cb2cb31c565800c4aa --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalAssetInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 58004290eb3aab44e9823d1f25c4ed73 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEmitterEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEmitterEditor.cs new file mode 100644 index 0000000000000000000000000000000000000000..5cfccbb1c4c3b98eadda57f24b3b64dfb78a2ebc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEmitterEditor.cs @@ -0,0 +1,23 @@ +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Signals +{ + [CustomTimelineEditor(typeof(SignalEmitter))] + class SignalEmitterEditor : MarkerEditor + { + static readonly string MissingAssetError = L10n.Tr("No signal assigned"); + + public override MarkerDrawOptions GetMarkerOptions(IMarker marker) + { + var options = base.GetMarkerOptions(marker); + SignalEmitter emitter = (SignalEmitter)marker; + if (emitter.asset != null) + options.tooltip = emitter.asset.name; + else + options.errorText = MissingAssetError; + + return options; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEmitterEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEmitterEditor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..4f40bf02ed6be8ae97ca357bc3762d5eb4eff970 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEmitterEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 51a7878f6c989394782db73339e90e46 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEmitterInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEmitterInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..9419b51b1baa503545af05f982e03738700a4bbe --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEmitterInspector.cs @@ -0,0 +1,377 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; +using UnityObject = UnityEngine.Object; + +namespace UnityEditor.Timeline.Signals +{ + [CustomEditor(typeof(SignalEmitter), true)] + [CanEditMultipleObjects] + class SignalEmitterInspector : MarkerInspector, ISignalAssetProvider + { + SerializedProperty m_RetroactiveProperty; + SerializedProperty m_EmitOnceProperty; + + SignalEmitter m_Signal; + GameObject m_BoundGameObject; + PlayableDirector m_AssociatedDirector; + bool m_TargetsHaveTheSameBinding; + + readonly Dictionary m_Editors = new Dictionary(); + readonly Dictionary m_Foldouts = new Dictionary(); + List m_Receivers = new List(); + + static GUIStyle s_FoldoutStyle; + internal static GUIStyle foldoutStyle + { + get + { + if (s_FoldoutStyle == null) + { + s_FoldoutStyle = new GUIStyle(EditorStyles.foldout) {fontStyle = FontStyle.Bold}; + } + + return s_FoldoutStyle; + } + } + + public SignalAsset signalAsset + { + get + { + var emitter = target as SignalEmitter; + return signalAssetSameValue ? emitter.asset : null; + } + set + { + AssignSignalAsset(value); + } + } + + bool signalAssetSameValue + { + get + { + var emitters = targets.Cast().ToList(); + return emitters.Select(x => x.asset).Distinct().Count() == 1; + } + } + + void OnEnable() + { + Undo.undoRedoPerformed += OnUndoRedo; // subscribe to the event + m_Signal = target as SignalEmitter; + m_RetroactiveProperty = serializedObject.FindProperty("m_Retroactive"); + m_EmitOnceProperty = serializedObject.FindProperty("m_EmitOnce"); + // In a vast majority of the cases, when this becomes enabled, + // the timeline window will be focused on the correct timeline + // in which case TimelineEditor.inspectedDirector is safe to use + m_AssociatedDirector = TimelineEditor.inspectedDirector; + UpdateState(); + } + + internal override bool IsEnabled() + { + return TimelineUtility.IsCurrentSequenceValid() && !IsCurrentSequenceReadOnly() && base.IsEnabled(); + } + + public override void OnInspectorGUI() + { + serializedObject.Update(); + + using (var changeScope = new EditorGUI.ChangeCheckScope()) + { + var property = serializedObject.GetIterator(); + var expanded = true; + while (property.NextVisible(expanded)) + { + expanded = false; + if (SkipField(property.propertyPath)) + continue; + EditorGUILayout.PropertyField(property, true); + } + + DrawSignalFlags(); + UpdateState(); + DrawNameSelectorAndSignalList(); + + if (changeScope.changed) + { + serializedObject.ApplyModifiedProperties(); + TimelineEditor.Refresh(RefreshReason.ContentsModified | RefreshReason.WindowNeedsRedraw); + } + } + } + + internal override void OnHeaderIconGUI(Rect iconRect) + { + using (new EditorGUI.DisabledScope(!TimelineUtility.IsCurrentSequenceValid() || IsCurrentSequenceReadOnly())) + { + GUI.Label(iconRect, Styles.SignalEmitterIcon); + } + } + + internal override Rect DrawHeaderHelpAndSettingsGUI(Rect r) + { + using (new EditorGUI.DisabledScope(!TimelineUtility.IsCurrentSequenceValid() || IsCurrentSequenceReadOnly())) + { + var helpSize = EditorStyles.iconButton.CalcSize(EditorGUI.GUIContents.helpIcon); + const int kTopMargin = 5; + return EditorGUIUtility.DrawEditorHeaderItems(new Rect(r.xMax - helpSize.x, r.y + kTopMargin, helpSize.x, helpSize.y), targets); + } + } + + IEnumerable ISignalAssetProvider.AvailableSignalAssets() + { + return SignalManager.assets; + } + + void ISignalAssetProvider.CreateNewSignalAsset(string path) + { + var newSignalAsset = SignalManager.CreateSignalAssetInstance(path); + AssignSignalAsset(newSignalAsset); + var receivers = m_Receivers.OfType().ToList(); + if (signalAsset != null && receivers.Count == 1 && !receivers.Any(r => r.IsSignalAssetHandled(newSignalAsset))) // Only when one receiver is present + { + receivers[0].AddNewReaction(newSignalAsset); // Add reaction on the first receiver from the list + ApplyChangesAndRefreshReceivers(); + } + } + + void UpdateState() + { + m_BoundGameObject = GetBoundGameObject(m_Signal.parent, m_AssociatedDirector); + m_Receivers = m_BoundGameObject == null || m_BoundGameObject.Equals(null) + ? new List() + : m_BoundGameObject.GetComponents().Where(t => t is INotificationReceiver).ToList(); + + m_TargetsHaveTheSameBinding = targets.Cast() + .Select(x => GetBoundGameObject(x.parent, m_AssociatedDirector)) + .Distinct().Count() == 1; + } + + Editor GetOrCreateReceiverEditor(Component c) + { + Editor ret; + if (m_Editors.TryGetValue(c, out ret)) + { + return ret; + } + + ret = CreateEditorWithContext(new Object[] {c}, target); + m_Editors[c] = ret; + if (!m_Foldouts.ContainsKey(c)) + { + m_Foldouts[c] = true; + } + + return ret; + } + + void OnDisable() + { + Undo.undoRedoPerformed -= OnUndoRedo; + } + + void OnDestroy() + { + foreach (var editor in m_Editors) + { + DestroyImmediate(editor.Value); + } + m_Editors.Clear(); + } + + void OnUndoRedo() + { + ApplyChangesAndRefreshReceivers(); + } + + void ApplyChangesAndRefreshReceivers() + { + foreach (var receiverInspector in m_Editors.Values.OfType()) + { + receiverInspector.SetAssetContext(signalAsset); + } + } + + void DrawNameSelectorAndSignalList() + { + using (var change = new EditorGUI.ChangeCheckScope()) + { + DrawSignal(); + DrawReceivers(); + + if (change.changed) + { + ApplyChangesAndRefreshReceivers(); + } + } + } + + void DrawReceivers() + { + if (!m_TargetsHaveTheSameBinding) + { + EditorGUILayout.HelpBox(Styles.MultiEditNotSupportedOnDifferentBindings, MessageType.None); + return; + } + + if (targets.OfType().Select(x => x.asset).Distinct().Count() > 1) + { + EditorGUILayout.HelpBox(Styles.MultiEditNotSupportedOnDifferentSignals, MessageType.None); + return; + } + + //do not display the receiver if the current timeline is not the same as the emitter's timeline + //can happen if the inspector is locked + if (m_Signal.parent != null && m_Signal.parent.timelineAsset != TimelineEditor.inspectedAsset) + return; + + if (m_BoundGameObject != null) + { + if (!m_Receivers.Any(x => x is SignalReceiver)) + { + EditorGUILayout.Separator(); + var message = string.Format(Styles.NoSignalReceiverComponent, m_BoundGameObject.name); + SignalUtility.DrawCenteredMessage(message); + if (SignalUtility.DrawCenteredButton(Styles.AddSignalReceiverComponent)) + AddReceiverComponent(); + } + + foreach (var receiver in m_Receivers) + { + var editor = GetOrCreateReceiverEditor(receiver); + if (DrawReceiverHeader(receiver)) + { + editor.OnInspectorGUI(); + } + } + } + else if (m_AssociatedDirector != null) //not in asset mode + { + EditorGUILayout.HelpBox(Styles.NoBoundGO, MessageType.None); + } + } + + void DrawSignalFlags() + { + EditorGUILayout.PropertyField(m_RetroactiveProperty, Styles.RetroactiveLabel); + EditorGUILayout.PropertyField(m_EmitOnceProperty, Styles.EmitOnceLabel); + } + + void DrawSignal() + { + //should show button to create new signal if there are no signals asset in the project + if (!SignalManager.assets.Any()) + { + using (new EditorGUI.DisabledScope(true)) + { + DrawNameSelector(); + } + + EditorGUILayout.Separator(); + SignalUtility.DrawCenteredMessage(Styles.ProjectHasNoSignalAsset); + if (SignalUtility.DrawCenteredButton(Styles.CreateNewSignal)) + CreateNewSignalAsset(SignalUtility.GetNewSignalPath()); + EditorGUILayout.Separator(); + } + else + { + DrawNameSelector(); + } + } + + internal void CreateNewSignalAsset(string path) + { + if (!string.IsNullOrEmpty(path)) + ((ISignalAssetProvider)this).CreateNewSignalAsset(path); + GUIUtility.ExitGUI(); + } + + void AssignSignalAsset(SignalAsset newAsset) + { + foreach (var o in targets) + { + var signalEmitter = (SignalEmitter)o; + UndoExtensions.RegisterMarker(signalEmitter, Styles.UndoCreateSignalAsset); + signalEmitter.asset = newAsset; + } + } + + void DrawNameSelector() + { + SignalUtility.DrawSignalNames(this, EditorGUILayout.GetControlRect(), Styles.EmitSignalLabel, !signalAssetSameValue); + } + + bool DrawReceiverHeader(Component receiver) + { + EditorGUILayout.Space(); + var lineRect = GUILayoutUtility.GetRect(10, 4, EditorStyles.inspectorTitlebar); + DrawSplitLine(lineRect.y); + + var style = EditorGUIUtility.TrTextContentWithIcon( + ObjectNames.NicifyVariableName(receiver.GetType().Name), + AssetPreview.GetMiniThumbnail(receiver)); + + m_Foldouts[receiver] = + EditorGUILayout.Foldout(m_Foldouts[receiver], style, true, foldoutStyle); + if (m_Foldouts[receiver]) + { + DrawReceiverObjectField(); + } + + return m_Foldouts[receiver]; + } + + void DrawReceiverObjectField() + { + EditorGUI.BeginDisabledGroup(true); + EditorGUILayout.ObjectField(Styles.ObjectLabel, m_BoundGameObject, typeof(GameObject), false); + EditorGUI.EndDisabledGroup(); + } + + void AddReceiverComponent() + { + var receiver = Undo.AddComponent(m_BoundGameObject); + receiver.AddNewReaction(signalAsset); + } + + static bool SkipField(string fieldName) + { + return fieldName == "m_Script" || fieldName == "m_Asset" || fieldName == "m_Retroactive" || fieldName == "m_EmitOnce"; + } + + static void DrawSplitLine(float y) + { + if (Event.current.type != EventType.Repaint) return; + + var width = EditorGUIUtility.currentViewWidth; + var position = new Rect(0, y, width + 1, 1); + + if (EditorStyles.inspectorTitlebar != null) + EditorStyles.inspectorTitlebar.Draw(position, false, false, false, false); + } + + static GameObject GetBoundGameObject(TrackAsset track, PlayableDirector associatedDirector) + { + if (associatedDirector == null || track == null) //if in asset mode, no bound object for you + return null; + + var boundObj = TimelineUtility.GetSceneGameObject(associatedDirector, track); + + //if the signal is on the timeline marker track and user did not set a binding, assume it's bound to PlayableDirector + if (boundObj == null && track.timelineAsset.markerTrack == track) + boundObj = associatedDirector.gameObject; + + return boundObj; + } + + static bool IsCurrentSequenceReadOnly() + { + return TimelineWindow.instance.state.editSequence.isReadOnly; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEmitterInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEmitterInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..d89a36caecf25d92a62da3105c8d30902e0788d9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEmitterInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 970e7735a0864fd40842a36d053d08fe +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEventDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEventDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..021c6c79e9e1afddaaee0b3d36c5757777c56503 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEventDrawer.cs @@ -0,0 +1,39 @@ +using System; +using JetBrains.Annotations; +using UnityEditorInternal; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Signals +{ + [CustomPropertyDrawer(typeof(CustomSignalEventDrawer))] + [UsedImplicitly] + class SignalEventDrawer : UnityEventDrawer + { + static GameObject FindBoundObject(SerializedProperty property) + { + var component = property.serializedObject.targetObject as Component; + return component != null ? component.gameObject : null; + } + + protected override void OnAddEvent(ReorderableList list) + { + base.OnAddEvent(list); + var listProperty = list.serializedProperty; + if (listProperty.arraySize > 0) + { + var lastCall = list.serializedProperty.GetArrayElementAtIndex(listProperty.arraySize - 1); + var targetProperty = lastCall.FindPropertyRelative(kInstancePath); + targetProperty.objectReferenceValue = FindBoundObject(listProperty); + } + } + + protected override void DrawEventHeader(Rect headerRect) {} + + protected override void SetupReorderableList(ReorderableList list) + { + base.SetupReorderableList(list); + list.headerHeight = 4; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEventDrawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEventDrawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..26afa8db2049e96b4a302f2f64e9bb36671b5e19 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalEventDrawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6ba7805325c426c43b8e85b5be4eae36 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalManager.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalManager.cs new file mode 100644 index 0000000000000000000000000000000000000000..4beec0c80ec7a225d4febe8cff376e44d3fea06d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalManager.cs @@ -0,0 +1,87 @@ +using System; +using System.Collections.Generic; +using System.IO; +using UnityEngine; +using UnityEngine.Timeline; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline.Signals +{ + class SignalManager : IDisposable + { + static SignalManager m_Instance; + readonly List m_assets = new List(); + + internal static SignalManager instance + { + get + { + if (m_Instance == null) + { + m_Instance = new SignalManager(); + m_Instance.Refresh(); + } + + return m_Instance; + } + + set { m_Instance = value; } + } + + internal SignalManager() + { + SignalAsset.OnEnableCallback += Register; + } + + public static IEnumerable assets + { + get + { + foreach (var asset in instance.m_assets) + { + if (asset != null) + yield return asset; + } + } + } + + public static SignalAsset CreateSignalAssetInstance(string path) + { + var newSignal = ScriptableObject.CreateInstance(); + newSignal.name = Path.GetFileNameWithoutExtension(path); + + var asset = AssetDatabase.LoadMainAssetAtPath(path) as SignalAsset; + if (asset != null) + { + TimelineUndo.PushUndo(asset, Styles.UndoCreateSignalAsset); + EditorUtility.CopySerialized(newSignal, asset); + Object.DestroyImmediate(newSignal); + return asset; + } + + AssetDatabase.CreateAsset(newSignal, path); + return newSignal; + } + + public void Dispose() + { + SignalAsset.OnEnableCallback -= Register; + } + + void Register(SignalAsset a) + { + m_assets.Add(a); + } + + void Refresh() + { + var guids = AssetDatabase.FindAssets("t:SignalAsset"); + foreach (var g in guids) + { + var path = AssetDatabase.GUIDToAssetPath(g); + var asset = AssetDatabase.LoadAssetAtPath(path); + m_assets.Add(asset); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalManager.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalManager.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..528ec1d2b720f54e62fefacff45895fd4b99dd24 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalManager.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 255b0c6d400fd964dab3029c8abc53f4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalReceiverHeader.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalReceiverHeader.cs new file mode 100644 index 0000000000000000000000000000000000000000..55e8d27e5e5dcfd0e6de51ef370d0bef688317e3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalReceiverHeader.cs @@ -0,0 +1,15 @@ +using UnityEditor.IMGUI.Controls; +using UnityEngine; + +namespace UnityEditor.Timeline.Signals +{ + class SignalReceiverHeader : MultiColumnHeader + { + public SignalReceiverHeader(MultiColumnHeaderState state) : base(state) {} + + protected override void AddColumnHeaderContextMenuItems(GenericMenu menu) + { + menu.AddItem(EditorGUIUtility.TrTextContent("Resize to Fit"), false, ResizeToFit); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalReceiverHeader.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalReceiverHeader.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..211c81009406e38f73e2ebdaa754a06599089ebe --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalReceiverHeader.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 423cd382a7804414d9bfdb2e7fb7bb62 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalReceiverInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalReceiverInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..52211e1dc436eafab34659dd813a889935d7f5bf --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalReceiverInspector.cs @@ -0,0 +1,116 @@ +using UnityEngine; +using UnityObject = UnityEngine.Object; +using UnityEditor.IMGUI.Controls; +using UnityEngine.Events; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Signals +{ + [CustomEditor(typeof(SignalReceiver))] + class SignalReceiverInspector : Editor + { + SignalReceiver m_Target; + + [SerializeField] TreeViewState m_TreeState; + [SerializeField] MultiColumnHeaderState m_MultiColumnHeaderState; + internal SignalReceiverTreeView m_TreeView; + + SignalEmitter signalEmitterContext + { + get { return m_Context as SignalEmitter;} + } + + void OnEnable() + { + m_Target = target as SignalReceiver; + InitTreeView(serializedObject); + + Undo.undoRedoPerformed += OnUndoRedo; + } + + void OnDisable() + { + Undo.undoRedoPerformed -= OnUndoRedo; + } + + void OnUndoRedo() + { + m_TreeView.dirty = true; + } + + public override void OnInspectorGUI() + { + serializedObject.Update(); + + using (var changeCheck = new EditorGUI.ChangeCheckScope()) + { + m_TreeView.RefreshIfDirty(); + DrawEmitterControls(); // Draws buttons coming from the Context (SignalEmitter) + + EditorGUILayout.Space(); + m_TreeView.Draw(); + + if (signalEmitterContext == null) + DrawAddRemoveButtons(); + + if (changeCheck.changed) + { + serializedObject.ApplyModifiedProperties(); + m_TreeView.dirty = true; + } + } + } + + void DrawEmitterControls() + { + var context = signalEmitterContext; + if (context != null) + { + var currentSignal = context.asset; + if (currentSignal != null && !m_Target.IsSignalAssetHandled(currentSignal)) + { + EditorGUILayout.Separator(); + var message = string.Format(Styles.NoReaction, currentSignal.name); + SignalUtility.DrawCenteredMessage(message); + if (SignalUtility.DrawCenteredButton(Styles.AddReactionButton)) + m_Target.AddNewReaction(currentSignal); // Add reaction on the first + EditorGUILayout.Separator(); + } + } + } + + internal void SetAssetContext(SignalAsset asset) + { + m_TreeView.SetSignalContext(asset); + } + + void DrawAddRemoveButtons() + { + using (new GUILayout.HorizontalScope()) + { + GUILayout.FlexibleSpace(); + if (GUILayout.Button(Styles.AddReactionButton)) + { + Undo.RecordObject(m_Target, Styles.UndoAddReaction); + m_Target.AddEmptyReaction(new UnityEvent()); + PrefabUtility.RecordPrefabInstancePropertyModifications(m_Target); + } + GUILayout.Space(18.0f); + } + } + + void InitTreeView(SerializedObject so) + { + m_TreeState = SignalListFactory.CreateViewState(); + m_MultiColumnHeaderState = SignalListFactory.CreateHeaderState(); + var header = SignalListFactory.CreateHeader(m_MultiColumnHeaderState, SignalReceiverUtility.headerHeight); + + var context = signalEmitterContext; + m_TreeView = SignalListFactory.CreateSignalInspectorList(m_TreeState, header, m_Target, so); + m_TreeView.readonlySignals = context != null; + + if (context != null) + m_TreeView.SetSignalContext(context.asset); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalReceiverInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalReceiverInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a764c958cdff5e204910a6832759622f39cbc9b1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalReceiverInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 70b265ed18dc14041bedc0263d4578ef +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalUtility.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalUtility.cs new file mode 100644 index 0000000000000000000000000000000000000000..663e341790eb9bede0a9bb965d8703aec03c1f19 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalUtility.cs @@ -0,0 +1,125 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Events; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Signals +{ + interface ISignalAssetProvider + { + SignalAsset signalAsset { get; set; } + IEnumerable AvailableSignalAssets(); + void CreateNewSignalAsset(string path); + } + + static class SignalUtility + { + const string k_SignalExtension = "signal"; + + public static void DrawSignalNames(ISignalAssetProvider assetProvider, Rect position, GUIContent label, bool multipleValues) + { + var assets = assetProvider.AvailableSignalAssets().ToList(); + var index = assets.IndexOf(assetProvider.signalAsset); + + var availableNames = new List(); + using (new GUIMixedValueScope(multipleValues)) + { + availableNames.Add(Styles.EmptySignalList.text); + + availableNames.AddRange(assets.Select(x => x.name)); + availableNames.Add(Styles.CreateNewSignal.text); + + var curValue = index + 1; + var selected = EditorGUI.Popup(position, label, curValue, availableNames.ToArray()); + + if (selected != curValue) + { + var noneEntryIdx = 0; + if (selected == noneEntryIdx) // None + assetProvider.signalAsset = null; + else if (selected == availableNames.Count - 1) // "Create New Asset" + { + var path = GetNewSignalPath(); + if (!string.IsNullOrEmpty(path)) + assetProvider.CreateNewSignalAsset(path); + GUIUtility.ExitGUI(); + } + else + assetProvider.signalAsset = assets[selected - 1]; + } + } + } + + public static string GetNewSignalPath() + { + return EditorUtility.SaveFilePanelInProject( + Styles.NewSignalWindowTitle.text, + Styles.NewSignalDefaultName.text, + k_SignalExtension, + Styles.NewSignalWindowMessage.text); + } + + public static bool IsSignalAssetHandled(this SignalReceiver receiver, SignalAsset asset) + { + return receiver != null && asset != null && receiver.GetRegisteredSignals().Contains(asset); + } + + public static void AddNewReaction(this SignalReceiver receiver, SignalAsset signalAsset) + { + if (signalAsset != null && receiver != null) + { + Undo.RecordObject(receiver, Styles.UndoAddReaction); + var newEvent = new UnityEvent(); + newEvent.AddPersistentListener(); + var evtIndex = newEvent.GetPersistentEventCount() - 1; + newEvent.RegisterVoidPersistentListenerWithoutValidation(evtIndex, receiver.gameObject, string.Empty); + receiver.AddReaction(signalAsset, newEvent); + PrefabUtility.RecordPrefabInstancePropertyModifications(receiver); + } + } + + public static void DrawCenteredMessage(string message) + { + using (new GUILayout.HorizontalScope()) + { + GUILayout.FlexibleSpace(); + GUILayout.Label(message); + GUILayout.FlexibleSpace(); + } + } + + public static bool DrawCenteredButton(GUIContent buttonLabel) + { + bool buttonClicked; + using (new GUILayout.HorizontalScope()) + { + GUILayout.FlexibleSpace(); + buttonClicked = GUILayout.Button(buttonLabel); + GUILayout.FlexibleSpace(); + } + return buttonClicked; + } + } + + static class SignalReceiverUtility + { + const int k_DefaultTreeviewHeaderHeight = 20; + + public static int headerHeight + { + get { return k_DefaultTreeviewHeaderHeight; } + } + + public static SerializedProperty FindSignalsProperty(SerializedObject obj) + { + return obj.FindProperty("m_Events.m_Signals"); + } + + public static SerializedProperty FindEventsProperty(SerializedObject obj) + { + return obj.FindProperty("m_Events.m_Events"); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalUtility.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalUtility.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..f29c92c9020bafafcf537a166f98448fb3e5b55e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/SignalUtility.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b33687803b08daf418e5315de17658b8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/Styles.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/Styles.cs new file mode 100644 index 0000000000000000000000000000000000000000..6842081f015f9339956fd3d9a298c7e5c1ec5f24 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/Styles.cs @@ -0,0 +1,39 @@ +using UnityEngine; + +namespace UnityEditor.Timeline.Signals +{ + static class Styles + { + public static readonly GUIContent RetroactiveLabel = EditorGUIUtility.TrTextContent("Retroactive", "Use retroactive to emit this signal even if playback starts afterwards."); + public static readonly GUIContent EmitOnceLabel = EditorGUIUtility.TrTextContent("Emit Once", "Emit the signal once during loops."); + public static readonly GUIContent EmitSignalLabel = EditorGUIUtility.TrTextContent("Emit Signal", "Select which Signal Asset to emit."); + public static readonly GUIContent ObjectLabel = EditorGUIUtility.TrTextContent("Receiver Component on", "The Signal Receiver Component on the bound GameObject."); + + public static readonly GUIContent CreateNewSignal = EditorGUIUtility.TrTextContent("Create Signal…"); + public static readonly GUIContent AddSignalReceiverComponent = EditorGUIUtility.TrTextContent("Add Signal Receiver", "Creates a Signal Receiver component on the track binding and the reaction for the current signal."); + public static readonly GUIContent EmptySignalList = EditorGUIUtility.TrTextContent("None"); + public static readonly GUIContent AddReactionButton = EditorGUIUtility.TrTextContent("Add Reaction"); + + public static readonly GUIContent NewSignalWindowTitle = EditorGUIUtility.TrTextContent("Create Signal Key"); + public static readonly GUIContent NewSignalDefaultName = EditorGUIUtility.TrTextContent("New Signal"); + public static readonly GUIContent NewSignalWindowMessage = EditorGUIUtility.TrTextContent("Create Signal Key"); + + public static readonly string SignalListDuplicateOption = L10n.Tr("Duplicate"); + public static readonly string SignalListDeleteOption = L10n.Tr("Delete"); + public static readonly string NoBoundGO = L10n.Tr("Track has no bound GameObject."); + public static readonly string MultiEditNotSupportedOnDifferentBindings = L10n.Tr("Multi-edit not supported for SignalReceivers on tracks bound to different GameObjects."); + public static readonly string MultiEditNotSupportedOnDifferentSignals = L10n.Tr("Multi-edit not supported for SignalReceivers when SignalEmitters use different Signals."); + + public static readonly string UndoCreateSignalAsset = L10n.Tr("Create New Signal Asset"); + public static readonly string UndoDuplicateRow = L10n.Tr("Duplicate Row"); + public static readonly string UndoDeleteRow = L10n.Tr("Delete Row"); + public static readonly string UndoAddReaction = L10n.Tr("Add Signal Receiver Reaction"); + public static readonly string NoReaction = L10n.Tr("No reaction for {0} has been defined in this receiver"); + public static readonly string NoSignalReceiverComponent = L10n.Tr("There is no Signal Receiver component on {0}"); + public static readonly string ProjectHasNoSignalAsset = L10n.Tr("Your project contains no Signal assets"); + + //Icons + public static readonly GUIStyle OptionsStyle = DirectorStyles.GetGUIStyle("Icon.Options"); + public static readonly GUIContent SignalEmitterIcon = EditorGUIUtility.IconContent("SignalEmitter Icon"); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/Styles.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/Styles.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..da7c0288e680879eff09147b100991f34b0b27ef --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/Styles.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 685f63932bebd0c4db02ee14845191e2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/TreeView.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/TreeView.meta new file mode 100644 index 0000000000000000000000000000000000000000..d8cac356d22444b5dd720e3079fa13656a4c27ef --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/TreeView.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 5ba130fc1db953547a50bcf5c162a3e8 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/TreeView/SignalListFactory.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/TreeView/SignalListFactory.cs new file mode 100644 index 0000000000000000000000000000000000000000..1b59ec6e7848c0151e61894dc772ffd726048ebc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/TreeView/SignalListFactory.cs @@ -0,0 +1,31 @@ +using System; +using UnityEditor.IMGUI.Controls; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Signals +{ + static class SignalListFactory + { + public static SignalReceiverTreeView CreateSignalInspectorList(TreeViewState state, SignalReceiverHeader header, SignalReceiver target, SerializedObject so) + { + return new SignalReceiverTreeView(state, header, target, so); + } + + public static SignalReceiverHeader CreateHeader(MultiColumnHeaderState state, int columnHeight) + { + var header = new SignalReceiverHeader(state) { height = columnHeight }; + header.ResizeToFit(); + return header; + } + + public static MultiColumnHeaderState CreateHeaderState() + { + return new MultiColumnHeaderState(SignalReceiverTreeView.GetColumns()); + } + + public static TreeViewState CreateViewState() + { + return new TreeViewState(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/TreeView/SignalListFactory.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/TreeView/SignalListFactory.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..fcc2a87c9985b1b0f73d1188cf0c1e4a37622ec7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Signals/TreeView/SignalListFactory.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 01cd96d8687272f4898cfd1562079dd7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/ISequenceState.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/ISequenceState.cs new file mode 100644 index 0000000000000000000000000000000000000000..5d328844aa3ad3ff1c1e8499bd45bbd67104afbf --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/ISequenceState.cs @@ -0,0 +1,106 @@ +using System; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + interface ISequenceState : IDisposable + { + TimelineAsset asset { get; } + PlayableDirector director { get; } + TimelineClip hostClip { get; } + double start { get; } + double timeScale { get; } + double duration { get; } + bool isReadOnly { get; } + TimelineAssetViewModel viewModel { get; } + double time { get; set; } + int frame { get; set; } + float frameRate { get; set; } + + Range GetEvaluableRange(); + string TimeAsString(double timeValue, string format = "F2"); + double ToGlobalTime(double t); + double ToLocalTime(double t); + void ResetIsReadOnly(); + } + + /** + * This class is used to hold default values for an implementation of ISequenceState. + * It could be removed in a phase 2, but it is currently used to limit the scope of + * this refactoring: it allows client code to access sequence info without having to + * worry about `currentSequence` being null. + * In the future this should be removed and we should pass around the correct data + * structure (i.e. SequenceState OR WindowState) based on the situation. + */ + class NullSequenceState : ISequenceState + { + public TimelineAsset asset { get { return null; } } + public PlayableDirector director { get { return null; } } + public TimelineClip hostClip { get { return null; } } + public double start { get { return 0.0; } } + public double timeScale { get { return 1.0; } } + public double duration { get { return 0.0; } } + public bool isReadOnly { get { return false; } } + + TimelineAssetViewModel m_ViewModel; + + public TimelineAssetViewModel viewModel + { + get + { + if (m_ViewModel == null) + m_ViewModel = TimelineWindowViewPrefs.CreateUnassociatedViewModel(); + return m_ViewModel; + } + } + + public double time + { + get { return 0.0; } + set { /* NO-OP*/ } + } + + public int frame + { + get { return 0; } + set { /* NO-OP*/ } + } + + public float frameRate + { + get { return TimelineAsset.EditorSettings.kDefaultFps; } + set { /* NO-OP*/ } + } + + public Range GetEvaluableRange() + { + return new Range(); + } + + public string TimeAsString(double timeValue, string format = "F2") + { + return TimeUtility.TimeAsTimeCode(timeValue, frameRate, format); + } + + public double ToGlobalTime(double t) + { + return t; + } + + public double ToLocalTime(double t) + { + return t; + } + + public void ResetIsReadOnly() + { + // NO-OP + } + + public void Dispose() + { + // NO-OP + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/ISequenceState.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/ISequenceState.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5b37827a101304558d643209423d642e77881a77 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/ISequenceState.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 167329c8289a3a14a9e342df49fc4104 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequenceHierarchy.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequenceHierarchy.cs new file mode 100644 index 0000000000000000000000000000000000000000..08a73e6b3b129339401920af925f83c30154089a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequenceHierarchy.cs @@ -0,0 +1,298 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class SequenceHierarchy : ScriptableObject + { + readonly List m_Sequences = new List(); + + WindowState m_WindowState; + + [SerializeField] + SequencePath m_SerializedPath; + + public ISequenceState masterSequence + { + get { return m_Sequences.FirstOrDefault(); } + } + + public ISequenceState editSequence + { + get { return m_Sequences.LastOrDefault(); } + } + + public int count + { + get { return m_Sequences.Count; } + } + + public IEnumerable allSequences + { + get { return m_Sequences; } + } + + public static SequenceHierarchy CreateInstance() + { + var hierarchy = ScriptableObject.CreateInstance(); + hierarchy.hideFlags = HideFlags.HideAndDontSave; + return hierarchy; + } + + public void Init(WindowState owner) + { + m_WindowState = owner; + } + + // This is called when performing Undo operations. + // It needs to be called here since some operations are not + // allowed (EditorUtility.InstanceIDToObject, for example) + // during the ISerializationCallbackReceiver methods. + void OnValidate() + { + if (m_SerializedPath == null || m_WindowState == null || m_WindowState.GetWindow() == null) + return; + + m_WindowState.SetCurrentSequencePath(m_SerializedPath, true); + } + + public void Add(TimelineAsset asset, PlayableDirector director, TimelineClip hostClip) + { + if (hostClip == null) + AddToCurrentUndoGroup(this); // Merge with selection undo + else + TimelineUndo.PushUndo(this, "Edit Sub-Timeline"); + + Add_Internal(asset, director, hostClip); + + UpdateSerializedPath(); + } + + public void Remove() + { + if (m_Sequences.Count == 0) return; + + TimelineUndo.PushUndo(this, "Go to Sub-Timeline"); + + Remove_Internal(); + + UpdateSerializedPath(); + } + + public ISequenceState GetStateAtIndex(int index) + { + return m_Sequences[index]; + } + + public void RemoveUntilCount(int expectedCount) + { + if (expectedCount < 0 || m_Sequences.Count <= expectedCount) return; + + TimelineUndo.PushUndo(this, "Go to Sub-Timeline"); + + RemoveUntilCount_Internal(expectedCount); + + UpdateSerializedPath(); + } + + public void Clear() + { + if (m_Sequences.Count == 0) return; + + AddToCurrentUndoGroup(this); + Clear_Internal(); + UpdateSerializedPath(); + } + + public SequencePath ToSequencePath() + { + var path = new SequencePath(); + + if (m_Sequences.Count == 0) + return path; + + var rootSequence = m_Sequences[0]; + var root = 0; + if (rootSequence.director != null && rootSequence.director.gameObject != null) + root = rootSequence.director.gameObject.GetInstanceID(); + else if (rootSequence.asset != null) + root = rootSequence.asset.GetInstanceID(); + + path.SetSelectionRoot(root); + + var resolver = rootSequence.director; + + if (m_Sequences.Count > 1) + { + for (int i = 1, n = m_Sequences.Count; i < n; ++i) + { + path.AddSubSequence(m_Sequences[i], resolver); + resolver = m_Sequences[i].director; + } + } + + return path; + } + + public bool NeedsUpdate(SequencePath path, bool forceRebuild) + { + return forceRebuild || !SequencePath.AreEqual(m_SerializedPath, path); + } + + public void FromSequencePath(SequencePath path, bool forceRebuild) + { + if (!NeedsUpdate(path, forceRebuild)) + return; + + Clear_Internal(); + + var rootObject = EditorUtility.InstanceIDToObject(path.selectionRoot); + if (rootObject == null) + { + UpdateSerializedPath(); + return; + } + + var candidateAsset = rootObject as TimelineAsset; + if (candidateAsset != null) + { + Add_Internal(candidateAsset, null, null); + UpdateSerializedPath(); + return; + } + + var candidateGameObject = rootObject as GameObject; + if (candidateGameObject == null) + { + UpdateSerializedPath(); + return; + } + + var director = TimelineUtility.GetDirectorComponentForGameObject(candidateGameObject); + var asset = TimelineUtility.GetTimelineAssetForDirectorComponent(director); + Add_Internal(asset, director, null); + + if (!path.subElements.Any()) + { + UpdateSerializedPath(); + return; + } + + List buildingBlocks; + if (ValidateSubElements(path.subElements, director, out buildingBlocks)) + { + foreach (var buildingBlock in buildingBlocks) + Add_Internal(buildingBlock.asset, buildingBlock.director, buildingBlock.hostClip); + } + + UpdateSerializedPath(); + } + + void Add_Internal(TimelineAsset asset, PlayableDirector director, TimelineClip hostClip) + { + if (hostClip == null) + Clear_Internal(); + + var parent = m_Sequences.Count > 0 ? editSequence : null; + m_Sequences.Add(new SequenceState(m_WindowState, asset, director, hostClip, (SequenceState)parent)); + } + + void Remove_Internal() + { + m_Sequences.Last().Dispose(); + m_Sequences.RemoveAt(m_Sequences.Count - 1); + } + + void RemoveUntilCount_Internal(int expectedCount) + { + while (m_Sequences.Count > expectedCount) + { + Remove_Internal(); + } + } + + void Clear_Internal() + { + RemoveUntilCount_Internal(0); + } + + void UpdateSerializedPath() + { + m_SerializedPath = ToSequencePath(); + } + + static bool ValidateSubElements(List subElements, PlayableDirector director, out List buildingBlocks) + { + buildingBlocks = new List(subElements.Count); + var currentDirector = director; + + foreach (var element in subElements) + { + var timeline = currentDirector.playableAsset as TimelineAsset; + if (timeline == null) + return false; + if (timeline.trackObjects == null) + return false; + + var track = timeline.GetOutputTracks().FirstOrDefault(t => t.GetInstanceID() == element.trackInstanceID); + if (track == null) + return false; + if (track.Hash() != element.trackHash) + return false; + if (track.clips == null) + return false; + if (track.clips.Length <= element.clipIndex) + return false; + + var clip = track.clips[element.clipIndex]; + if (clip == null) + return false; + if (clip.Hash() != element.clipHash) + return false; + + var candidateDirectors = TimelineUtility.GetSubTimelines(clip, director); + + if (element.subDirectorIndex < 0 || element.subDirectorIndex >= candidateDirectors.Count) + return false; + + var candidateDirector = candidateDirectors[element.subDirectorIndex]; + + if (candidateDirector == null || !(candidateDirector.playableAsset is TimelineAsset)) + return false; + + currentDirector = candidateDirector; + + buildingBlocks.Add( + new SequenceBuildingBlock + { + asset = currentDirector.playableAsset as TimelineAsset, + director = currentDirector, + hostClip = clip + }); + } + + return true; + } + + struct SequenceBuildingBlock + { + public TimelineAsset asset; + public PlayableDirector director; + public TimelineClip hostClip; + } + + static void AddToCurrentUndoGroup(Object target) + { + if (target == null) return; + + var group = Undo.GetCurrentGroup(); + var groupName = Undo.GetCurrentGroupName(); + EditorUtility.SetDirty(target); + Undo.RegisterCompleteObjectUndo(target, groupName); + Undo.CollapseUndoOperations(group); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequenceHierarchy.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequenceHierarchy.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1e9c089d4dd902bde29a69d620dc885b74a91910 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequenceHierarchy.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6901fab4d5157ac48b9f263730387c03 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequencePath.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequencePath.cs new file mode 100644 index 0000000000000000000000000000000000000000..d7270412faa6f43406554469e1709a8f282bff31 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequencePath.cs @@ -0,0 +1,131 @@ +using System; +using System.Collections.Generic; +using System.Text; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [Serializable] + class SequencePath + { + [SerializeField] int m_SelectionRoot; + + public int selectionRoot + { + get { return m_SelectionRoot; } + } + + [SerializeField] List m_SubElements; + + public List subElements + { + get { return m_SubElements ?? (m_SubElements = new List()); } + } + + public void SetSelectionRoot(int instanceID) + { + m_SelectionRoot = instanceID; + subElements.Clear(); + } + + public void AddSubSequence(ISequenceState state, IExposedPropertyTable resolver) + { + subElements.Add(SequencePathSubElement.Create(state, resolver)); + } + + public void Clear() + { + m_SelectionRoot = 0; + subElements.Clear(); + } + + public static bool AreEqual(SequencePath lhs, SequencePath rhs) + { + if (ReferenceEquals(lhs, null) && ReferenceEquals(rhs, null)) return true; + if (ReferenceEquals(lhs, null) || ReferenceEquals(rhs, null)) return false; + if (ReferenceEquals(lhs, rhs)) return true; + + var result = lhs.selectionRoot == rhs.selectionRoot && + lhs.subElements.Count == rhs.subElements.Count; + + if (!result) + return false; + + for (int i = 0, n = lhs.subElements.Count; i < n; ++i) + result = result && SequencePathSubElement.AreEqual(lhs.subElements[i], rhs.subElements[i]); + + return result; + } + + public override string ToString() + { + var sb = new StringBuilder(); + + sb.AppendFormat("[{0}]", m_SelectionRoot.ToString()); + + if (m_SubElements != null && m_SubElements.Count > 0) + { + foreach (var element in m_SubElements) + { + sb.Append(" > "); + sb.Append(element.ToString()); + } + } + + return sb.ToString(); + } + } + + [Serializable] + class SequencePathSubElement + { + public int trackInstanceID; + public int trackHash; + public int clipIndex; + public int clipHash; + public int subDirectorIndex; + + public static SequencePathSubElement Create(ISequenceState state, IExposedPropertyTable resolver) + { + var clip = state.hostClip; + Debug.Assert(clip != null); + var track = clip.parentTrack; + Debug.Assert(track != null); + var asset = track.timelineAsset; + Debug.Assert(asset != null); + var directors = TimelineUtility.GetSubTimelines(clip, resolver as PlayableDirector); + + return new SequencePathSubElement + { + trackInstanceID = track.GetInstanceID(), + trackHash = track.Hash(), + clipIndex = Array.IndexOf(track.clips, clip), + clipHash = clip.Hash(), + subDirectorIndex = directors.IndexOf(state.director) + }; + } + + public static bool AreEqual(SequencePathSubElement lhs, SequencePathSubElement rhs) + { + if (ReferenceEquals(lhs, null) && ReferenceEquals(rhs, null)) return true; + if (ReferenceEquals(lhs, null) || ReferenceEquals(rhs, null)) return false; + if (ReferenceEquals(lhs, rhs)) return true; + + return lhs.trackInstanceID == rhs.trackInstanceID && + lhs.trackHash == rhs.trackHash && + lhs.clipIndex == rhs.clipIndex && + lhs.clipHash == rhs.clipHash && + lhs.subDirectorIndex == rhs.subDirectorIndex; + } + + public override string ToString() + { + return string.Format( + "[track[{0}] ({1}) > clip[{2}] ({3})]", + trackInstanceID.ToString(), trackHash.ToString(), + clipIndex.ToString(), clipHash.ToString()); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequencePath.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequencePath.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..9d76ca59651da17697f09a9cfee91f2fd3b72cbb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequencePath.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d1207768d96c479488b6b81f3483e0c1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequenceState.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequenceState.cs new file mode 100644 index 0000000000000000000000000000000000000000..f2a4f4d62d33ebfdf3107525a4e02faeeb2fb0d8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequenceState.cs @@ -0,0 +1,212 @@ +using System; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class SequenceState : ISequenceState + { + readonly WindowState m_WindowState; + readonly SequenceState m_ParentSequence; + + double m_Time; + Range? m_CachedEvaluableRange; + + public TimelineAsset asset { get; } + public PlayableDirector director { get; } + public TimelineClip hostClip { get; } + public double start { get; } + public double timeScale { get; } + + public double duration + { + get + { + if (asset == null) + return 0.0; + + var assetDuration = asset.durationMode == TimelineAsset.DurationMode.FixedLength ? asset.fixedDuration : asset.duration; + return hostClip == null ? assetDuration : Math.Min(hostClip.duration, assetDuration); + } + } + + bool? m_IsReadOnly; + public bool isReadOnly + { + get + { + if (!m_IsReadOnly.HasValue) + m_IsReadOnly = FileUtil.IsReadOnly(asset); + return m_IsReadOnly.Value; + } + } + + public void ResetIsReadOnly() + { + m_IsReadOnly = null; + } + + public TimelineAssetViewModel viewModel + { + get + { + return TimelineWindowViewPrefs.GetOrCreateViewModel(asset); + } + } + + public double time + { + get + { + if (m_ParentSequence != null) + return hostClip.ToLocalTimeUnbound(m_ParentSequence.time); + + return GetLocalTime(); + } + set + { + var correctedValue = Math.Min(value, TimeUtility.k_MaxTimelineDurationInSeconds); + viewModel.windowTime = correctedValue; + + if (m_ParentSequence != null) + m_ParentSequence.time = hostClip.FromLocalTimeUnbound(correctedValue); + else + SetLocalTime(correctedValue); + } + } + + public int frame + { + get { return TimeUtility.ToFrames(time, frameRate); } + set { time = TimeUtility.FromFrames(Mathf.Max(0, value), frameRate); } + } + + public float frameRate + { + get + { + if (asset != null) + return asset.editorSettings.fps; + + return TimelineAsset.EditorSettings.kDefaultFps; + } + set + { + TimelineAsset.EditorSettings settings = asset.editorSettings; + if (Math.Abs(settings.fps - value) > TimeUtility.kFrameRateEpsilon) + { + settings.fps = Mathf.Max(value, (float)TimeUtility.kFrameRateEpsilon); + EditorUtility.SetDirty(asset); + } + } + } + + public SequenceState(WindowState windowState, TimelineAsset asset, PlayableDirector director, TimelineClip hostClip, SequenceState parentSequence) + { + m_WindowState = windowState; + m_ParentSequence = parentSequence; + + this.asset = asset; + this.director = director; + this.hostClip = hostClip; + + start = hostClip == null ? 0.0 : hostClip.start; + timeScale = hostClip == null ? 1.0 : hostClip.timeScale * parentSequence.timeScale; + } + + public Range GetEvaluableRange() + { + if (hostClip == null) + return new Range + { + start = 0.0, + end = duration + }; + + if (!m_CachedEvaluableRange.HasValue) + { + var globalRange = GetGlobalEvaluableRange(); + m_CachedEvaluableRange = new Range + { + start = ToLocalTime(globalRange.start), + end = ToLocalTime(globalRange.end) + }; + } + + return m_CachedEvaluableRange.Value; + } + + public string TimeAsString(double timeValue, string format = "F2") + { + if (TimelinePreferences.instance.timeUnitInFrame) + return TimeUtility.TimeAsFrames(timeValue, frameRate, format); + + return TimeUtility.TimeAsTimeCode(timeValue, frameRate, format); + } + + public double ToGlobalTime(double t) + { + if (hostClip == null) + return t; + + return m_ParentSequence.ToGlobalTime(hostClip.FromLocalTimeUnbound(t)); + } + + public double ToLocalTime(double t) + { + if (hostClip == null) + return t; + + return hostClip.ToLocalTimeUnbound(m_ParentSequence.ToLocalTime(t)); + } + + double GetLocalTime() + { + if (!m_WindowState.previewMode && !Application.isPlaying) + return viewModel.windowTime; + + // the time needs to always be synchronized with the director + if (director != null) + m_Time = director.time; + + return m_Time; + } + + void SetLocalTime(double newTime) + { + // do this prior to the calback, because the callback pulls from the get + if (director != null) + director.time = newTime; + + if (Math.Abs(m_Time - newTime) > TimeUtility.kTimeEpsilon) + { + m_Time = newTime; + m_WindowState.InvokeTimeChangeCallback(); + } + } + + Range GetGlobalEvaluableRange() + { + if (hostClip == null) + return new Range + { + start = 0.0, + end = duration + }; + + var currentRange = new Range + { + start = hostClip.ToLocalTimeUnbound(ToGlobalTime(hostClip.start)), + end = hostClip.ToLocalTimeUnbound(ToGlobalTime(hostClip.end)) + }; + + return Range.Intersection(currentRange, m_ParentSequence.GetGlobalEvaluableRange()); + } + + public void Dispose() + { + TimelineWindowViewPrefs.SaveViewModel(asset); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequenceState.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequenceState.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..8e8e6cc4666eba32b091a3fc060ee599d92da6a3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/SequenceState.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 09f4db536a377bc40a9ac110af702bfa +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/WindowState.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/WindowState.cs new file mode 100644 index 0000000000000000000000000000000000000000..eae672264b94b0c0b6df8947495d1dae92556a17 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/WindowState.cs @@ -0,0 +1,1151 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.Experimental.SceneManagement; +using UnityEngine.Experimental.Animations; +using UnityEditorInternal; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; +using UnityEngine.Animations; + +namespace UnityEditor.Timeline +{ + delegate bool PendingUpdateDelegate(WindowState state, Event currentEvent); + + class WindowState + { + const int k_TimeCodeTextFieldId = 3790; + + readonly TimelineWindow m_Window; + bool m_Recording; + + readonly SpacePartitioner m_SpacePartitioner = new SpacePartitioner(); + readonly SpacePartitioner m_HeaderSpacePartitioner = new SpacePartitioner(); + readonly List m_CaptureSession = new List(); + + int m_DirtyStamp; + float m_BindingAreaWidth = WindowConstants.defaultBindingAreaWidth; + + bool m_MustRebuildGraph; + + float m_LastTime; + + readonly PropertyCollector m_PropertyCollector = new PropertyCollector(); + + static AnimationModeDriver s_PreviewDriver; + List m_PreviewedAnimators; + List m_PreviewedComponents; + + public static double kTimeEpsilon { get { return TimeUtility.kTimeEpsilon; } } + public static readonly float kMaxShownTime = (float)TimeUtility.k_MaxTimelineDurationInSeconds; + + static readonly ISequenceState k_NullSequenceState = new NullSequenceState(); + + // which tracks are armed for record - only one allowed per 'actor' + Dictionary m_ArmedTracks = new Dictionary(); + + TimelineWindow.TimelineWindowPreferences m_Preferences; + + List m_OnStartFrameUpdates; + List m_OnEndFrameUpdates; + + readonly SequenceHierarchy m_SequenceHierarchy; + + public event Action windowOnGuiStarted; + public event Action windowOnGuiFinished; + + public event Action OnPlayStateChange; + public event System.Action OnDirtyStampChange; + public event System.Action OnRebuildGraphChange; + public event System.Action OnTimeChange; + public event System.Action OnRecordingChange; + + public event System.Action OnBeforeSequenceChange; + public event System.Action OnAfterSequenceChange; + + public WindowState(TimelineWindow w, SequenceHierarchy hierarchy) + { + m_Window = w; + m_Preferences = w.preferences; + hierarchy.Init(this); + m_SequenceHierarchy = hierarchy; + TimelinePlayable.muteAudioScrubbing = muteAudioScrubbing; + } + + public static AnimationModeDriver previewDriver + { + get + { + if (s_PreviewDriver == null) + { + s_PreviewDriver = ScriptableObject.CreateInstance(); + AnimationPreviewUtilities.s_PreviewDriver = s_PreviewDriver; + } + return s_PreviewDriver; + } + } + + public EditorWindow editorWindow + { + get { return m_Window; } + } + + public ISequenceState editSequence + { + get + { + // Using "null" ISequenceState to avoid checking against null all the time. + // This *should* be removed in a phase 2 of refactoring, where we make sure + // to pass around the correct state object instead of letting clients dig + // into the WindowState for whatever they want. + return m_SequenceHierarchy.editSequence ?? k_NullSequenceState; + } + } + + public ISequenceState masterSequence + { + get { return m_SequenceHierarchy.masterSequence ?? k_NullSequenceState; } + } + + public ISequenceState referenceSequence + { + get { return timeReferenceMode == TimeReferenceMode.Local ? editSequence : masterSequence; } + } + + public bool rebuildGraph + { + get { return m_MustRebuildGraph; } + set { SyncNotifyValue(ref m_MustRebuildGraph, value, OnRebuildGraphChange); } + } + + public float mouseDragLag { get; set; } + + public SpacePartitioner spacePartitioner + { + get { return m_SpacePartitioner; } + } + + public SpacePartitioner headerSpacePartitioner + { + get { return m_HeaderSpacePartitioner; } + } + + public List captured + { + get { return m_CaptureSession; } + } + + public void AddCaptured(Manipulator manipulator) + { + if (!m_CaptureSession.Contains(manipulator)) + m_CaptureSession.Add(manipulator); + } + + public void RemoveCaptured(Manipulator manipulator) + { + m_CaptureSession.Remove(manipulator); + } + + public bool isJogging { get; set; } + + public int viewStateHash { get; private set; } + + public float bindingAreaWidth + { + get { return m_BindingAreaWidth; } + set { m_BindingAreaWidth = value; } + } + + public float sequencerHeaderWidth + { + get { return editSequence.viewModel.sequencerHeaderWidth; } + set + { + editSequence.viewModel.sequencerHeaderWidth = Mathf.Clamp(value, WindowConstants.minHeaderWidth, WindowConstants.maxHeaderWidth); + } + } + + public float mainAreaWidth { get; set; } + + public float trackScale + { + get { return editSequence.viewModel.trackScale; } + set + { + editSequence.viewModel.trackScale = value; + m_Window.treeView.CalculateRowRects(); + } + } + + public int dirtyStamp + { + get { return m_DirtyStamp; } + private set { SyncNotifyValue(ref m_DirtyStamp, value, OnDirtyStampChange); } + } + + public bool showQuadTree { get; set; } + + public bool canRecord + { + get { return AnimationMode.InAnimationMode(previewDriver) || !AnimationMode.InAnimationMode(); } + } + + public bool recording + { + get + { + if (!previewMode) + m_Recording = false; + return m_Recording; + } + // set can only be used to disable recording + set + { + if (ignorePreview) + return; + + // force preview mode on + if (value) + previewMode = true; + + bool newValue = value; + if (!previewMode) + newValue = false; + + if (newValue && m_ArmedTracks.Count == 0) + { + Debug.LogError("Cannot enable recording without an armed track"); + newValue = false; + } + + if (!newValue) + m_ArmedTracks.Clear(); + + if (newValue != m_Recording) + { + if (newValue) + AnimationMode.StartAnimationRecording(); + else + AnimationMode.StopAnimationRecording(); + + InspectorWindow.RepaintAllInspectors(); + } + + SyncNotifyValue(ref m_Recording, newValue, OnRecordingChange); + } + } + + public bool previewMode + { + get { return ignorePreview || AnimationMode.InAnimationMode(previewDriver); } + set + { + if (ignorePreview) + return; + bool inAnimationMode = AnimationMode.InAnimationMode(previewDriver); + if (!value) + { + if (inAnimationMode) + { + Stop(); + + OnStopPreview(); + + AnimationMode.StopAnimationMode(previewDriver); + + AnimationPropertyContextualMenu.Instance.SetResponder(null); + previewedDirectors = null; + } + } + else if (!inAnimationMode) + { + editSequence.time = editSequence.viewModel.windowTime; + EvaluateImmediate(); // does appropriate caching prior to enabling + } + } + } + + public bool playing + { + get + { + return masterSequence.director != null && masterSequence.director.state == PlayState.Playing; + } + } + + public float playbackSpeed { get; set; } + + public bool frameSnap + { + get { return TimelinePreferences.instance.snapToFrame; } + set { TimelinePreferences.instance.snapToFrame = value; } + } + + public bool edgeSnaps + { + get { return TimelinePreferences.instance.edgeSnap; } + set { TimelinePreferences.instance.edgeSnap = value; } + } + + public bool muteAudioScrubbing + { + get { return !TimelinePreferences.instance.audioScrubbing; } + set + { + TimelinePreferences.instance.audioScrubbing = !value; + TimelinePlayable.muteAudioScrubbing = value; + RebuildPlayableGraph(); + } + } + + public bool playRangeLoopMode + { + get { return m_Preferences.playRangeLoopMode; } + set { m_Preferences.playRangeLoopMode = value; } + } + + public TimeReferenceMode timeReferenceMode + { + get { return m_Preferences.timeReferenceMode; } + set { m_Preferences.timeReferenceMode = value; } + } + + public bool timeInFrames + { + get { return TimelinePreferences.instance.timeUnitInFrame; } + set { TimelinePreferences.instance.timeUnitInFrame = value; } + } + + public bool showAudioWaveform + { + get { return TimelinePreferences.instance.showAudioWaveform; } + set { TimelinePreferences.instance.showAudioWaveform = value; } + } + + public Vector2 playRange + { + get { return masterSequence.viewModel.timeAreaPlayRange; } + set { masterSequence.viewModel.timeAreaPlayRange = ValidatePlayRange(value); } + } + + public bool showMarkerHeader + { + get { return editSequence.viewModel.showMarkerHeader; } + set { GetWindow().SetShowMarkerHeader(value); } + } + + void UnSelectMarkerOnHeaderTrack() + { + foreach (IMarker marker in SelectionManager.SelectedMarkers()) + { + if (marker.parent == editSequence.asset.markerTrack) + SelectionManager.Remove(marker); + } + } + + public EditMode.EditType editType + { + get { return m_Preferences.editType; } + set { m_Preferences.editType = value; } + } + + public PlaybackScrollMode autoScrollMode + { + get { return TimelinePreferences.instance.playbackScrollMode; } + set { TimelinePreferences.instance.playbackScrollMode = value; } + } + + public bool isClipSnapping { get; set; } + + public List previewedDirectors { get; private set; } + + public void OnDestroy() + { + if (!ignorePreview) + Stop(); + + if (m_OnStartFrameUpdates != null) + m_OnStartFrameUpdates.Clear(); + + if (m_OnEndFrameUpdates != null) + m_OnEndFrameUpdates.Clear(); + + m_SequenceHierarchy.Clear(); + windowOnGuiStarted = null; + windowOnGuiFinished = null; + } + + public void OnSceneSaved() + { + // the director will reset it's time when the scene is saved. + EnsureWindowTimeConsistency(); + } + + public void SetCurrentSequence(TimelineAsset timelineAsset, PlayableDirector director, TimelineClip hostClip) + { + if (OnBeforeSequenceChange != null) + OnBeforeSequenceChange.Invoke(); + + OnCurrentDirectorWillChange(); + + if (hostClip == null || timelineAsset == null) + { + m_PropertyCollector.Clear(); + m_SequenceHierarchy.Clear(); + } + + if (timelineAsset != null) + m_SequenceHierarchy.Add(timelineAsset, director, hostClip); + + if (OnAfterSequenceChange != null) + OnAfterSequenceChange.Invoke(); + } + + public void PopSequencesUntilCount(int count) + { + if (count >= m_SequenceHierarchy.count) return; + if (count < 1) return; + + if (OnBeforeSequenceChange != null) + OnBeforeSequenceChange.Invoke(); + + var nextDirector = m_SequenceHierarchy.GetStateAtIndex(count - 1).director; + OnCurrentDirectorWillChange(); + + m_SequenceHierarchy.RemoveUntilCount(count); + + EnsureWindowTimeConsistency(); + + if (OnAfterSequenceChange != null) + OnAfterSequenceChange.Invoke(); + } + + public SequencePath GetCurrentSequencePath() + { + return m_SequenceHierarchy.ToSequencePath(); + } + + public void SetCurrentSequencePath(SequencePath path, bool forceRebuild) + { + if (!m_SequenceHierarchy.NeedsUpdate(path, forceRebuild)) + return; + + if (OnBeforeSequenceChange != null) + OnBeforeSequenceChange.Invoke(); + + m_SequenceHierarchy.FromSequencePath(path, forceRebuild); + + if (OnAfterSequenceChange != null) + OnAfterSequenceChange.Invoke(); + } + + public IEnumerable GetAllSequences() + { + return m_SequenceHierarchy.allSequences; + } + + public void Reset() + { + recording = false; + previewMode = false; + } + + public double GetSnappedTimeAtMousePosition(Vector2 mousePos) + { + return TimeReferenceUtility.SnapToFrameIfRequired(ScreenSpacePixelToTimeAreaTime(mousePos.x)); + } + + static void SyncNotifyValue(ref T oldValue, T newValue, System.Action changeStateCallback) + { + var stateChanged = false; + + if (oldValue == null) + { + oldValue = newValue; + stateChanged = true; + } + else + { + if (!oldValue.Equals(newValue)) + { + oldValue = newValue; + stateChanged = true; + } + } + + if (stateChanged && changeStateCallback != null) + { + changeStateCallback.Invoke(); + } + } + + public void SetTimeAreaTransform(Vector2 newTranslation, Vector2 newScale) + { + m_Window.timeArea.SetTransform(newTranslation, newScale); + TimeAreaChanged(); + } + + public void SetTimeAreaShownRange(float min, float max) + { + m_Window.timeArea.SetShownHRange(min, max); + TimeAreaChanged(); + } + + internal void TimeAreaChanged() + { + if (editSequence.asset != null) + { + Vector2 newShownRange = new Vector2(m_Window.timeArea.shownArea.x, m_Window.timeArea.shownArea.xMax); + if (editSequence.viewModel.timeAreaShownRange != newShownRange) + { + editSequence.viewModel.timeAreaShownRange = newShownRange; + if (!FileUtil.IsReadOnly(editSequence.asset)) + EditorUtility.SetDirty(editSequence.asset); + } + } + } + + public void ResetPreviewMode() + { + var mode = previewMode; + previewMode = false; + previewMode = mode; + } + + public bool TimeIsInRange(float value) + { + Rect shownArea = m_Window.timeArea.shownArea; + return value >= shownArea.x && value <= shownArea.xMax; + } + + public bool RangeIsVisible(Range range) + { + var shownArea = m_Window.timeArea.shownArea; + return range.start < shownArea.xMax && range.end > shownArea.xMin; + } + + public void EnsurePlayHeadIsVisible() + { + double minDisplayedTime = PixelToTime(timeAreaRect.xMin); + double maxDisplayedTime = PixelToTime(timeAreaRect.xMax); + + double currentTime = editSequence.time; + if (currentTime >= minDisplayedTime && currentTime <= maxDisplayedTime) + return; + + float displayedTimeRange = (float)(maxDisplayedTime - minDisplayedTime); + float minimumTimeToDisplay = (float)currentTime - displayedTimeRange / 2.0f; + float maximumTimeToDisplay = (float)currentTime + displayedTimeRange / 2.0f; + SetTimeAreaShownRange(minimumTimeToDisplay, maximumTimeToDisplay); + } + + public void SetPlayHeadToMiddle() + { + double minDisplayedTime = PixelToTime(timeAreaRect.xMin); + double maxDisplayedTime = PixelToTime(timeAreaRect.xMax); + + double currentTime = editSequence.time; + float displayedTimeRange = (float)(maxDisplayedTime - minDisplayedTime); + + if (currentTime >= minDisplayedTime && currentTime <= maxDisplayedTime) + { + if (currentTime < minDisplayedTime + displayedTimeRange / 2) + return; + } + + const float kCatchUpSpeed = 3f; + float realDelta = Mathf.Clamp(Time.realtimeSinceStartup - m_LastTime, 0f, 1f) * kCatchUpSpeed; + float scrollCatchupAmount = kCatchUpSpeed * realDelta * displayedTimeRange / 2; + + if (currentTime < minDisplayedTime) + { + SetTimeAreaShownRange((float)currentTime, (float)currentTime + displayedTimeRange); + } + else if (currentTime > maxDisplayedTime) + { + SetTimeAreaShownRange((float)currentTime - displayedTimeRange + scrollCatchupAmount, (float)currentTime + scrollCatchupAmount); + } + else if (currentTime > minDisplayedTime + displayedTimeRange / 2) + { + float targetMinDisplayedTime = Mathf.Min((float)minDisplayedTime + scrollCatchupAmount, + (float)(currentTime - displayedTimeRange / 2)); + SetTimeAreaShownRange(targetMinDisplayedTime, targetMinDisplayedTime + displayedTimeRange); + } + } + + internal void UpdateLastFrameTime() + { + m_LastTime = Time.realtimeSinceStartup; + } + + public Vector2 timeAreaShownRange + { + get + { + if (m_Window.state.editSequence.asset != null) + return editSequence.viewModel.timeAreaShownRange; + + return TimelineAssetViewModel.TimeAreaDefaultRange; + } + set + { + SetTimeAreaShownRange(value.x, value.y); + } + } + + public Vector2 timeAreaTranslation + { + get { return m_Window.timeArea.translation; } + } + + public Vector2 timeAreaScale + { + get { return m_Window.timeArea.scale; } + } + + public Rect timeAreaRect + { + get + { + var sequenceContentRect = m_Window.sequenceContentRect; + return new Rect( + sequenceContentRect.x, + WindowConstants.timeAreaYPosition, + Mathf.Max(sequenceContentRect.width, WindowConstants.timeAreaMinWidth), + WindowConstants.timeAreaHeight + ); + } + } + + public float windowHeight + { + get { return m_Window.position.height; } + } + + public bool playRangeEnabled + { + get { return !ignorePreview && masterSequence.viewModel.playRangeEnabled && !IsEditingASubTimeline(); } + set + { + if (!ignorePreview) + masterSequence.viewModel.playRangeEnabled = value; + } + } + + public bool ignorePreview + { + get + { + var shouldIgnorePreview = masterSequence.asset != null && !masterSequence.asset.editorSettings.scenePreview; + return Application.isPlaying || shouldIgnorePreview; + } + } + + public TimelineWindow GetWindow() + { + return m_Window; + } + + public void Play() + { + if (masterSequence.director == null) + return; + + if (!previewMode) + previewMode = true; + + if (previewMode) + { + if (masterSequence.time > masterSequence.duration) + masterSequence.time = 0; + + masterSequence.director.Play(); + masterSequence.director.ProcessPendingGraphChanges(); + PlayableDirector.ResetFrameTiming(); + InvokePlayStateChangeCallback(true); + } + } + + public void Pause() + { + if (masterSequence.director != null) + { + masterSequence.director.Pause(); + masterSequence.director.ProcessPendingGraphChanges(); + SynchronizeSequencesAfterPlayback(); + InvokePlayStateChangeCallback(false); + } + } + + public void SetPlaying(bool start) + { + if (start && !playing) + { + Play(); + } + + if (!start && playing) + { + Pause(); + } + } + + public void Stop() + { + if (masterSequence.director != null) + { + masterSequence.director.Stop(); + masterSequence.director.ProcessPendingGraphChanges(); + InvokePlayStateChangeCallback(false); + } + } + + void InvokePlayStateChangeCallback(bool isPlaying) + { + if (OnPlayStateChange != null) + OnPlayStateChange.Invoke(isPlaying); + } + + public void RebuildPlayableGraph() + { + if (masterSequence.director != null) + { + masterSequence.director.RebuildGraph(); + // rebuild both the parent and the edit sequences. control tracks don't necessary + // rebuild the subdirector on recreation + if (editSequence.director != null && editSequence.director != masterSequence.director) + { + editSequence.director.RebuildGraph(); + } + } + } + + public void Evaluate() + { + if (masterSequence.director != null) + { + if (!EditorApplication.isPlaying && !previewMode) + GatherProperties(masterSequence.director); + + ForceTimeOnDirector(masterSequence.director); + masterSequence.director.DeferredEvaluate(); + + if (EditorApplication.isPlaying == false) + { + PlayModeView.RepaintAll(); + SceneView.RepaintAll(); + AudioMixerWindow.RepaintAudioMixerWindow(); + } + } + } + + public void EvaluateImmediate() + { + if (masterSequence.director != null && masterSequence.director.isActiveAndEnabled) + { + if (!EditorApplication.isPlaying && !previewMode) + GatherProperties(masterSequence.director); + + if (previewMode) + { + ForceTimeOnDirector(masterSequence.director); + masterSequence.director.ProcessPendingGraphChanges(); + masterSequence.director.Evaluate(); + } + } + } + + public void Refresh() + { + CheckRecordingState(); + dirtyStamp = dirtyStamp + 1; + + rebuildGraph = true; + } + + public void UpdateViewStateHash() + { + viewStateHash = timeAreaTranslation.GetHashCode() + .CombineHash(timeAreaScale.GetHashCode()) + .CombineHash(trackScale.GetHashCode()); + } + + public bool IsEditingASubTimeline() + { + return editSequence != masterSequence; + } + + public bool IsEditingAnEmptyTimeline() + { + return editSequence.asset == null; + } + + public bool IsEditingAPrefabAsset() + { + var stage = PrefabStageUtility.GetCurrentPrefabStage(); + return stage != null && editSequence.director != null && stage.IsPartOfPrefabContents(editSequence.director.gameObject); + } + + public bool IsCurrentEditingASequencerTextField() + { + if (editSequence.asset == null) + return false; + + if (k_TimeCodeTextFieldId == GUIUtility.keyboardControl) + return true; + + return editSequence.asset.flattenedTracks.Count(t => t.GetInstanceID() == GUIUtility.keyboardControl) != 0; + } + + public float TimeToTimeAreaPixel(double t) // TimeToTimeAreaPixel + { + float pixelX = (float)t; + pixelX *= timeAreaScale.x; + pixelX += timeAreaTranslation.x + sequencerHeaderWidth; + return pixelX; + } + + public float TimeToScreenSpacePixel(double time) + { + float pixelX = (float)time; + pixelX *= timeAreaScale.x; + pixelX += timeAreaTranslation.x; + return pixelX; + } + + public float TimeToPixel(double time) + { + return m_Window.timeArea.TimeToPixel((float)time, timeAreaRect); + } + + public float PixelToTime(float pixel) + { + return m_Window.timeArea.PixelToTime(pixel, timeAreaRect); + } + + public float PixelDeltaToDeltaTime(float p) + { + return PixelToTime(p) - PixelToTime(0); + } + + public float TimeAreaPixelToTime(float pixel) + { + return PixelToTime(pixel); + } + + public float ScreenSpacePixelToTimeAreaTime(float p) + { + // transform into track space by offsetting the pixel by the screen-space offset of the time area + p -= timeAreaRect.x; + return TrackSpacePixelToTimeAreaTime(p); + } + + public float TrackSpacePixelToTimeAreaTime(float p) + { + p -= timeAreaTranslation.x; + + if (timeAreaScale.x > 0.0f) + return p / timeAreaScale.x; + + return p; + } + + public void OffsetTimeArea(int pixels) + { + Vector3 tx = timeAreaTranslation; + tx.x += pixels; + SetTimeAreaTransform(tx, timeAreaScale); + } + + public GameObject GetSceneReference(TrackAsset asset) + { + if (editSequence.director == null) + return null; // no player bound + + return TimelineUtility.GetSceneGameObject(editSequence.director, asset); + } + + public void CalculateRowRects() + { + // arming a track might add inline curve tracks, recalc track heights + if (m_Window != null && m_Window.treeView != null) + m_Window.treeView.CalculateRowRects(); + } + + // Only one track within a 'track' hierarchy can be armed + public void ArmForRecord(TrackAsset track) + { + m_ArmedTracks[TimelineUtility.GetSceneReferenceTrack(track)] = track; + if (track != null && !recording) + recording = true; + if (!recording) + return; + + track.OnRecordingArmed(editSequence.director); + CalculateRowRects(); + } + + public void UnarmForRecord(TrackAsset track) + { + m_ArmedTracks.Remove(TimelineUtility.GetSceneReferenceTrack(track)); + if (m_ArmedTracks.Count == 0) + recording = false; + track.OnRecordingUnarmed(editSequence.director); + } + + public void UpdateRecordingState() + { + if (recording) + { + foreach (var track in m_ArmedTracks.Values) + { + if (track != null) + track.OnRecordingTimeChanged(editSequence.director); + } + } + } + + public bool IsTrackRecordable(TrackAsset track) + { + // A track with animated parameters can always be recorded to + return IsArmedForRecord(track) || track.HasAnyAnimatableParameters(); + } + + public bool IsArmedForRecord(TrackAsset track) + { + return track == GetArmedTrack(track); + } + + public TrackAsset GetArmedTrack(TrackAsset track) + { + TrackAsset outTrack; + m_ArmedTracks.TryGetValue(TimelineUtility.GetSceneReferenceTrack(track), out outTrack); + return outTrack; + } + + void CheckRecordingState() + { + // checks for deleted tracks, and makes sure the recording state matches + if (m_ArmedTracks.Any(t => t.Value == null)) + { + m_ArmedTracks = m_ArmedTracks.Where(t => t.Value != null).ToDictionary(t => t.Key, t => t.Value); + if (m_ArmedTracks.Count == 0) + recording = false; + } + } + + void OnCurrentDirectorWillChange() + { + if (ignorePreview) + return; + + SynchronizeViewModelTime(editSequence); + Stop(); + rebuildGraph = true; // needed for asset previews + } + + public void GatherProperties(PlayableDirector director) + { + if (director == null || Application.isPlaying) + return; + + var asset = director.playableAsset as TimelineAsset; + if (asset != null && !asset.editorSettings.scenePreview) + return; + + if (!previewMode) + { + AnimationMode.StartAnimationMode(previewDriver); + + OnStartPreview(director); + + AnimationPropertyContextualMenu.Instance.SetResponder(new TimelineRecordingContextualResponder(this)); + if (!previewMode) + return; + EnsureWindowTimeConsistency(); + } + + if (asset != null) + { + m_PropertyCollector.Reset(); + m_PropertyCollector.PushActiveGameObject(null); // avoid overflow on unbound tracks + asset.GatherProperties(director, m_PropertyCollector); + } + } + + void OnStartPreview(PlayableDirector director) + { + previewedDirectors = TimelineUtility.GetAllDirectorsInHierarchy(director).ToList(); + + if (previewedDirectors == null) + return; + + m_PreviewedAnimators = TimelineUtility.GetBindingsFromDirectors(previewedDirectors).ToList(); + + m_PreviewedComponents = new List(); + foreach (var animator in m_PreviewedAnimators) + { + m_PreviewedComponents.AddRange(animator.GetComponents()); + } + foreach (var previewedComponent in m_PreviewedComponents) + { + previewedComponent.StartPreview(); + } + } + + void OnStopPreview() + { + if (m_PreviewedComponents != null) + { + foreach (var previewComponent in m_PreviewedComponents) + { + if (previewComponent != null) + { + previewComponent.StopPreview(); + } + } + m_PreviewedComponents = null; + } + + if (m_PreviewedAnimators != null) + { + foreach (var previewAnimator in m_PreviewedAnimators) + { + if (previewAnimator != null) + { + previewAnimator.UnbindAllHandles(); + } + } + m_PreviewedAnimators = null; + } + } + + internal void ProcessStartFramePendingUpdates() + { + if (m_OnStartFrameUpdates != null) + m_OnStartFrameUpdates.RemoveAll(callback => callback.Invoke(this, Event.current)); + } + + internal void ProcessEndFramePendingUpdates() + { + if (m_OnEndFrameUpdates != null) + m_OnEndFrameUpdates.RemoveAll(callback => callback.Invoke(this, Event.current)); + } + + public void AddStartFrameDelegate(PendingUpdateDelegate updateDelegate) + { + if (m_OnStartFrameUpdates == null) + m_OnStartFrameUpdates = new List(); + if (m_OnStartFrameUpdates.Contains(updateDelegate)) + return; + m_OnStartFrameUpdates.Add(updateDelegate); + } + + public void AddEndFrameDelegate(PendingUpdateDelegate updateDelegate) + { + if (m_OnEndFrameUpdates == null) + m_OnEndFrameUpdates = new List(); + if (m_OnEndFrameUpdates.Contains(updateDelegate)) + return; + m_OnEndFrameUpdates.Add(updateDelegate); + } + + internal void InvokeWindowOnGuiStarted(Event evt) + { + if (windowOnGuiStarted != null) + windowOnGuiStarted.Invoke(this, evt); + } + + internal void InvokeWindowOnGuiFinished(Event evt) + { + if (windowOnGuiFinished != null) + windowOnGuiFinished.Invoke(this, evt); + } + + public void UpdateRootPlayableDuration(double duration) + { + if (editSequence.director != null) + { + if (editSequence.director.playableGraph.IsValid()) + { + if (editSequence.director.playableGraph.GetRootPlayableCount() > 0) + { + var rootPlayable = editSequence.director.playableGraph.GetRootPlayable(0); + if (rootPlayable.IsValid()) + rootPlayable.SetDuration(duration); + } + } + } + } + + public void InvokeTimeChangeCallback() + { + if (OnTimeChange != null) + OnTimeChange.Invoke(); + } + + Vector2 ValidatePlayRange(Vector2 range) + { + if (range == TimelineAssetViewModel.NoPlayRangeSet) + return range; + + float minimumPlayRangeTime = 0.01f / Mathf.Max(1.0f, referenceSequence.frameRate); + + // Validate min + if (range.y - range.x < minimumPlayRangeTime) + range.x = range.y - minimumPlayRangeTime; + + if (range.x < 0.0f) + range.x = 0.0f; + + // Validate max + if (range.y > editSequence.duration) + range.y = (float)editSequence.duration; + + if (range.y - range.x < minimumPlayRangeTime) + range.y = Mathf.Min(range.x + minimumPlayRangeTime, (float)editSequence.duration); + + return range; + } + + void EnsureWindowTimeConsistency() + { + if (masterSequence.director != null && masterSequence.viewModel != null && !ignorePreview) + masterSequence.time = masterSequence.viewModel.windowTime; + } + + void SynchronizeSequencesAfterPlayback() + { + // Synchronizing editSequence will synchronize all view models up to the master + SynchronizeViewModelTime(editSequence); + } + + static void SynchronizeViewModelTime(ISequenceState state) + { + if (state.director == null || state.viewModel == null) + return; + + var t = state.time; + state.time = t; + } + + // because we may be evaluating outside the duration of the root playable + // we explicitly set the time - this causes the graph to not 'advance' the time + // because advancing it can force it to change due to wrapping to the duration + // This can happen if the graph is force evaluated outside it's duration + // case 910114, 936844 and 943377 + static void ForceTimeOnDirector(PlayableDirector director) + { + var directorTime = director.time; + director.time = directorTime; + } + + public bool IsPlayableGraphDone() + { + return masterSequence.director != null + && masterSequence.director.playableGraph.IsValid() + && masterSequence.director.playableGraph.IsDone(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/WindowState.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/WindowState.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..37183a96f15a08b6dd2e3bf8ea218a99124e8251 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/State/WindowState.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: df8df80bb65e9ec4280229a9921c4f3c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions.meta new file mode 100644 index 0000000000000000000000000000000000000000..00826661f220826aa22120efb0e29c4c3977b87f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: fa68ac03b8845a142974ec6497cb4acc +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/common.uss b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/common.uss new file mode 100644 index 0000000000000000000000000000000000000000..6be5d820b25ef4586f2acabf445efd7ac35f36be --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/common.uss @@ -0,0 +1,1055 @@ +.Color-Selected { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 20; + + /* GUIStyle.fixedWidth */ + width: 6; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.name */ + -unity-name: "Color.Selected"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIState.textColor */ + color: rgb(12, 180, 204); +} + +/* GUIStyle.active */ +.Color-Selected:hover:active { + /* GUIState.textColor */ + color: rgb(12, 180, 204); +} + +/* GUIStyle.focused */ +.Color-Selected:focus { + /* GUIState.textColor */ + color: rgb(255, 255, 255); +} + +.Font-Clip { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fontSize */ + font-size: --unity-font-size-small; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.name */ + -unity-name: "Font.Clip"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.groupBackground { + + -unity-slice-left: 5; + -unity-slice-top: 5; + -unity-slice-bottom: 5; + + -unity-clipping: clip; + -unity-image-position: text-only; + + padding-top: 2; + padding-bottom: 2; + + -unity-stretch-height: true; + color: rgb(115, 151, 236); + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Shared/TimelineGroupBackground.png"); +} + +/* GUIStyle.active */ +.groupBackground:hover:active { + /* GUIState.textColor */ + color: rgb(137, 196, 255); +} + +.Icon-Activation { + /* GUIStyle.alignment */ + -unity-text-align: middle-left; + + /* GUIStyle.fixedHeight */ + height: 15; + + /* GUIStyle.fontSize */ + font-size: --unity-font-size; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + + /* GUIStyle.name */ + -unity-name: "Icon.Activation"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIState.textColor */ + color: rgba(0, 0, 0, 0.75); +} + +.trackRecordButton { + height: 16; + width: 16; + -unity-text-align: middle-center; + font-size: --unity-font-size; + -unity-image-position: image-only; + -unity-rich-text: false; + -unity-stretch-width: false; +} + +.trackAvatarMaskButton { + height: 16; + width: 16; + -unity-text-align: middle-center; + font-size: --unity-font-size + -unity-image-position: image-only; + -unity-rich-text: false; + -unity-stretch-width: false; +} + +.Icon-ClipIn { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 8; + + /* GUIStyle.fixedWidth */ + width: 4; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.name */ + -unity-name: "Icon.ClipIn"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.Icon-ClipOut { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 8; + + /* GUIStyle.fixedWidth */ + width: 4; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.name */ + -unity-name: "Icon.ClipOut"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.Icon-Connector { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 5; + + /* GUIStyle.fixedWidth */ + width: 7; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.name */ + -unity-name: "Icon.Connector"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Shared/TimelineConnector.png"); +} + +.trackCurvesButton { + -unity-text-align: middle-center; + -unity-clipping: clip; + height: 16; + width: 16; + font-size: 72; + -unity-rich-text: false; + -unity-stretch-width: false; +} + +.Icon-Endmarker { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.fixedHeight */ + height: 14; + + /* GUIStyle.fixedWidth */ + width: 5; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.margin */ + margin-left: 4; + margin-right: 4; + margin-top: 4; + margin-bottom: 4; + + /* GUIStyle.name */ + -unity-name: "Icon.Endmarker"; + + /* GUIStyle.padding */ + padding-left: 4; + padding-right: 4; + padding-top: 4; + padding-bottom: 4; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Shared/TimelineSeqEnd.png"); +} + +.MarkerItem { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.fixedHeight */ + height: 16; + + /* GUIStyle.fixedWidth */ + width: 9; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + +} + +.SignalEmitter { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.fixedHeight */ + height: 16; + + /* GUIStyle.fixedWidth */ + width: 9; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; +} + +.trackCollapseMarkerButton { + -unity-text-align: middle-center; + height: 16; + width: 16; + -unity-image-position: image-only; +} + +.MarkerMultiOverlay { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.fixedHeight */ + height: 16; + + /* GUIStyle.fixedWidth */ + width: 9; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Shared/Timeline-Marker-Multi-Overlay.png"); +} + +.Icon-ExtrapolationContinue { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 11; + + /* GUIStyle.fixedWidth */ + width: 14; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + + /* GUIStyle.name */ + -unity-name: "Icon.ExtrapolationContinue"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.Icon-ExtrapolationHold { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 11; + + /* GUIStyle.fixedWidth */ + width: 14; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + + /* GUIStyle.name */ + -unity-name: "Icon.ExtrapolationHold"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.Icon-ExtrapolationLoop { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 11; + + /* GUIStyle.fixedWidth */ + width: 14; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + + /* GUIStyle.name */ + -unity-name: "Icon.ExtrapolationLoop"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.Icon-ExtrapolationPingPong { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 11; + + /* GUIStyle.fixedWidth */ + width: 14; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + + /* GUIStyle.name */ + -unity-name: "Icon.ExtrapolationPingPong"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.Icon-Foldout { + /* GUIStyle.alignment */ + -unity-text-align: middle-left; + + /* GUIStyle.fixedWidth */ + width: 13; + + /* GUIStyle.fixedWidth */ + height: 13; + + /* GUIStyle.fontSize */ + font-size: --unity-font-size; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + + /* GUIStyle.name */ + -unity-name: "Icon.Foldout"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.Icon-InfiniteTrack { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + -unity-slice-top: 5; + -unity-slice-bottom: 5; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fontSize */ + font-size: --unity-font-size; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-above; + + /* GUIStyle.name */ + -unity-name: "Icon.InfiniteTrack"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIStyle.wordWrap */ + -unity-word-wrap: true; +} + +/* GUIStyle.active */ +.Icon-InfiniteTrack:hover:active { + /* GUIState.textColor */ + color: rgba(0, 0, 0, 0.96); +} + +.Icon-Keyframe { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 8; + + /* GUIStyle.fixedWidth */ + width: 9; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + + /* GUIStyle.name */ + -unity-name: "Icon.Keyframe"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.trackLockOverlay { + -unity-text-align: middle-center; + font-size: 72; + -unity-image-position: text-only; + -unity-rich-text: false; + -unity-stretch-width: false; + color: rgb(37, 45, 50); +} + +.trackMuteButton { + -unity-text-align: middle-center; + height: 16; + width: 16; + font-size: --unity-font-size; + -unity-image-position: image-only; + -unity-rich-text: false; + -unity-stretch-width: false; +} + +.trackLockButton { + -unity-text-align: middle-center; + height: 16; + width: 16; + font-size: --unity-font-size; + -unity-image-position: image-only; + -unity-rich-text: false; + -unity-stretch-width: false; +} + +.Icon-Options { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 14; + + /* GUIStyle.fixedWidth */ + width: 14; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.margin */ + margin-left: 10; + margin-right: 5; + + /* GUIStyle.name */ + -unity-name: "Icon.Options"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIState.textColor */ + color: rgb(37, 45, 50); +} + +.Icon-OutlineBorder { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.border */ + -unity-slice-left: 5; + -unity-slice-right: 5; + -unity-slice-top: 5; + -unity-slice-bottom: 5; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fontSize */ + font-size: --unity-font-size; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-above; + + /* GUIStyle.name */ + -unity-name: "Icon.OutlineBorder"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIStyle.wordWrap */ + -unity-word-wrap: true; + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Shared/TimelineOutline.png"); +} + +/* GUIStyle.active */ +.Icon-OutlineBorder:hover:active { + /* GUIState.textColor */ + color: rgba(0, 0, 0, 0.96); +} + +.Icon-PlayAreaEnd { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 20; + + /* GUIStyle.fixedWidth */ + width: 6; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.name */ + -unity-name: "Icon.PlayAreaEnd"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.Icon-PlayAreaStart { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 20; + + /* GUIStyle.fixedWidth */ + width: 6; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.name */ + -unity-name: "Icon.PlayAreaStart"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.Icon-Playrange { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 25; + + /* GUIStyle.fixedWidth */ + width: 6; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + + /* GUIStyle.name */ + -unity-name: "Icon.Playrange"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.Icon-Shadow { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + + /* GUIStyle.name */ + -unity-name: "Icon.Shadow"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Shared/TimelineBottomShadow.png"); +} + +.Icon-TimeCursor { + /* GUIStyle.alignment */ + -unity-text-align: middle-left; + + /* GUIStyle.fixedHeight */ + height: 20; + + /* GUIStyle.fixedWidth */ + width: 11; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.margin */ + margin-left: 4; + margin-right: 4; + margin-top: 4; + margin-bottom: 4; + + /* GUIStyle.name */ + -unity-name: "Icon.TimeCursor"; + + /* GUIStyle.padding */ + padding-left: 4; + padding-right: 4; + padding-top: 4; + padding-bottom: 4; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIState.textColor */ + color: rgb(255, 255, 255); +} + +.Icon-TrackHeaderSwatch { + /* GUIStyle.alignment */ + -unity-text-align: middle-left; + -unity-slice-top: 4; + -unity-slice-bottom: 4; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedWidth */ + width: 4; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.name */ + -unity-name: "Icon.TrackHeaderSwatch"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Shared/TimelineSwatch.png"); +} + +/* GUIStyle.active */ +.Icon-TrackHeaderSwatch:hover:active { + /* GUIState.textColor */ + color: rgb(137, 196, 255); +} + +.Icon-TrackOptions { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fixedHeight */ + height: 16; + + /* GUIStyle.fixedWidth */ + width: 16; + + /* GUIStyle.fontSize */ + font-size: --unity-font-size; + + /* GUIStyle.name */ + -unity-name: "Icon.TrackOptions"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIStyle.wordWrap */ + -unity-word-wrap: true; +} + +/* GUIStyle.active */ +.Icon-TrackOptions:hover:active { + /* GUIState.textColor */ + color: rgba(0, 0, 0, 0.96); +} + +.Icon-Warning { + /* GUIStyle.alignment */ + -unity-text-align: middle-center; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fontSize */ + font-size: 72; + + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + + /* GUIStyle.name */ + -unity-name: "Icon.Warning"; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Shared/TimelineWarning.png"); +} + +.sequenceClip { + /* GUIStyle.alignment */ + -unity-text-align: middle-left; + + /* GUIStyle.border */ + -unity-slice-left: 5; + -unity-slice-right: 5; + -unity-slice-top: 5; + -unity-slice-bottom: 5; + + /* GUIStyle.clipping */ + -unity-clipping: clip; + + /* GUIStyle.fontSize */ + font-size: --unity-font-size-tiny; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + padding-top: 2; + padding-bottom: 2; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchHeight */ + -unity-stretch-height: true; + + /* GUIState.textColor */ + color: rgb(115, 151, 236); + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Shared/TimelineDisplay.png"); +} + +/* GUIStyle.active */ +.sequenceClip:hover:active { + /* GUIState.textColor */ + color: rgb(137, 196, 255); +} + +.sequenceGroupFont { + /* GUIStyle.alignment */ + -unity-text-align: middle-left; + + /* GUIStyle.fontSize */ + font-size: --unity-font-size; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; +} + +.sequenceTrackHeaderFont { + /* GUIStyle.alignment */ + -unity-text-align: middle-left; + + /* GUIStyle.fontSize */ + font-size: --unity-font-size; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.padding */ + padding-left: 5; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIState.textColor */ + color: rgb(153, 153, 153); +} + +.tinyFont { + /* GUIStyle.alignment */ + -unity-text-align: middle-left; + + /* GUIStyle.fontSize */ + font-size: --unity-font-size-tiny; + + /* GUIStyle.imagePosition */ + -unity-image-position: text-only; + + /* GUIStyle.richText */ + -unity-rich-text: false; + + /* GUIStyle.stretchWidth */ + -unity-stretch-width: false; + + /* GUIState.textColor */ + color: rgba(255, 255, 255, 0.75); +} + +.editModeBtn { + padding-left: 8px; + padding-right: 8px; + padding-top: 4px; + padding-bottom: 3px; + -unity-extend: ".ToolbarPopup"; + background-image: resource(""); +} + +.showMarkerBtn{ + margin: 0px 0px 6px 6px; + padding-left: 12px; + padding-right: 12px; + padding-top: 4px; + padding-bottom: 3px; + -unity-extend: ".ToolbarPopup"; + background-image: resource(""); +} + +.sequenceSwitcher{ + margin: 0px 5px 0px 0px; + padding-left: 0px; + padding-right: 0px; + padding-top: 0px; + padding-bottom: 0px; + -unity-extend: ".ToolbarPopup"; + background-image: resource(""); + -unity-text-align: middle-center; +} + +.markerWarningOverlay{ + height: 13px; + width: 14px; + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/Timeline-Marker-Warning-Overlay.png"); +} + +.timeReferenceButton { + -unity-extend: ".toolbarbutton"; + padding-left: 6px; + padding-right: 6px; + padding-top: 0px; + padding-bottom: 0px; + -unity-text-align: middle-center; + font-size: --unity-font-size-small; +} + +.trackButtonSuite { + height: 22px; + border-radius: 3px; + margin-left: 1px; + margin-right: 1px; + margin-top: -3px; + padding-left: 3px; + padding-right: 4px; +} + +.previewButtonDisabled { + -unity-extend: ".toolbarbutton"; + padding-left: 0px; + padding-right: 0px; + -unity-text-align: middle-center; +} + +.markerHeaderMuteButton {} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/common.uss.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/common.uss.meta new file mode 100644 index 0000000000000000000000000000000000000000..5f90bc87a8add8a6cd5fc1881203663a884beede --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/common.uss.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ada555936059fa149bb48537842ee230 +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0} + disableValidation: 1 diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/dark.uss b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/dark.uss new file mode 100644 index 0000000000000000000000000000000000000000..9662effb92875b26f2fdca84848d08388f8fb3ca --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/dark.uss @@ -0,0 +1,255 @@ +.Font-Clip { + /* GUIState.textColor */ + color: rgb(255, 255, 255); +} + +.Icon-Activation { + /* GUIStyle.fixedWidth */ + width: 12; + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineActivation.png"); +} + +.trackRecordButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonDisabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonDisabled@2x.png"); +} + +.trackRecordButton:checked { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonEnabled@2x.png"); +} + +.trackAvatarMaskButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonDisabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonDisabled@2x.png"); +} + +.trackAvatarMaskButton:checked { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonEnabled@2x.png"); +} + +.Icon-ClipIn { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineIconClipIn.png"); +} + +.Icon-ClipOut { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineIconClipOut.png"); +} + +.Icon-ClipSelected { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineClipGradientSelected.png"); +} + +.trackCurvesButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonDisabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonDisabled@2x.png"); +} + +.trackCurvesButton:checked { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonEnabled@2x.png"); +} + +.Icon-Endmarker { + /* GUIState.textColor */ + color: rgb(61, 94, 152); +} + +.MarkerItem { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineMarkerItemCollapsed.png"); +} + +.MarkerItem:checked { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineMarkerItem.png"); +} + +.MarkerItem:hover:focus:checked { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineMarkerItemSelected.png"); +} + +.SignalEmitter { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineSignalCollapsed.png"); +} + +.SignalEmitter:checked { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TimelineSignal.png"); +} + +.SignalEmitter:hover:focus:checked { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineSignalSelected.png"); +} + +.trackCollapseMarkerButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonDisabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonDisabled@2x.png"); +} + +.trackCollapseMarkerButton:checked { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonEnabled@2x.png"); +} + +.Icon-ExtrapolationContinue { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineContinue.png"); + + /* GUIStyle.contentOffset */ + -unity-content-offset: -5 0; +} + +.Icon-ExtrapolationHold { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineHold.png"); +} + +.Icon-ExtrapolationLoop { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineLoop.png"); +} + +.Icon-ExtrapolationPingPong { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelinePingPong.png"); +} + +.Icon-Foldout { + /* GUIState.background */ + background-image: resource("Builtin Skins/DarkSkin/Images/IN foldout.png"); + + /* GUIState.scaledBackgrounds */ + -unity-scaled-backgrounds: resource("Builtin Skins/DarkSkin/Images/IN foldout@2x.png"); +} + +/* GUIStyle.active */ +.Icon-Foldout:hover:active { + /* GUIState.background */ + background-image: resource("Builtin Skins/DarkSkin/Images/IN foldout on.png"); + + /* GUIState.scaledBackgrounds */ + -unity-scaled-backgrounds: resource("Builtin Skins/DarkSkin/Images/IN foldout on@2x.png"); +} + +/* GUIStyle.onActive */ +.Icon-Foldout:hover:active:checked { + /* GUIState.background */ + background-image: resource("Builtin Skins/DarkSkin/Images/IN foldout on.png"); + + /* GUIState.scaledBackgrounds */ + -unity-scaled-backgrounds: resource("Builtin Skins/DarkSkin/Images/IN foldout on@2x.png"); +} + +/* GUIStyle.onNormal */ +.Icon-Foldout:checked { + /* GUIState.background */ + background-image: resource("Builtin Skins/DarkSkin/Images/IN foldout on.png"); + + /* GUIState.scaledBackgrounds */ + -unity-scaled-backgrounds: resource("Builtin Skins/DarkSkin/Images/IN foldout on@2x.png"); +} + +.Icon-InfiniteTrack { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineInfiniteTrackNoShadow.png"); +} + +.Icon-Keyframe { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineKeyframe.png"); +} + +.trackLockOverlay { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineDisabledBackground.png"); +} + +.trackMuteButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonDisabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonDisabled@2x.png"); +} + +.trackMuteButton:checked { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonEnabled@2x.png"); +} + +.trackLockButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackLockButtonDisabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackLockButtonDisabled@2x.png"); + } + +.trackLockButton:checked { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackLockButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackLockButtonEnabled@2x.png"); +} + +.Icon-Options { + /* GUIState.background */ + background-image: resource("Icons/d__Popup.png"); +} + +.Icon-PlayAreaEnd { + /* GUIState.textColor */ + color: rgb(187, 189, 191); + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineEndPlayback.png"); +} + +.Icon-PlayAreaStart { + /* GUIState.textColor */ + color: rgb(187, 189, 191); + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineStartPlayback.png"); +} + +.Icon-Playrange { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelinePlayRange.png"); +} + +.Icon-TimeCursor { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/DarkSkin/TimelineTimeCursor.png"); +} + +.Icon-TrackOptions { + /* GUIStyle.imagePosition */ + -unity-image-position: image-only; + + /* GUIState.background */ + background-image: resource("Builtin Skins/DarkSkin/Images/pane options.png"); + + /* GUIState.scaledBackgrounds */ + -unity-scaled-backgrounds: resource("Builtin Skins/DarkSkin/Images/pane options@2x.png"); +} + +.sequenceGroupFont { + /* GUIState.textColor */ + color: rgb(204, 204, 204); +} + +.sequenceSwitcher{ + background-color: rgb(51, 51, 51); +} + +.trackButtonSuite { + background-color: rgba(40, 40, 40, 0.75); +} + +.markerHeaderMuteButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonEnabled@2x.png"); +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/dark.uss.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/dark.uss.meta new file mode 100644 index 0000000000000000000000000000000000000000..a6c0372bcddab4da4cbe6555bfb43606caf3f294 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/dark.uss.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5393cdb70614ab24f94f78bfcf5d1455 +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0} + disableValidation: 1 diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/light.uss b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/light.uss new file mode 100644 index 0000000000000000000000000000000000000000..c892b916b753f09e40e5d495385a105ae951369d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/light.uss @@ -0,0 +1,252 @@ +.Icon-Activation { + /* GUIStyle.fixedWidth */ + width: 10; + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineActivation.png"); +} + +.trackRecordButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackRecordButtonDisabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackRecordButtonDisabled@2x.png"); +} + +.trackRecordButton:checked { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackRecordButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackRecordButtonEnabled@2x.png"); +} + +.trackAvatarMaskButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackAvatarButtonDisabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/AvatarMaskDisabled.png"); +} + +.trackAvatarMaskButton:checked { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackAvatarButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackAvatarButtonEnabled.png"); +} + +.Icon-ClipIn { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineIconClipIn.png"); +} + +.Icon-ClipOut { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineIconClipOut.png"); +} + +.Icon-ClipSelected { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineClipGradientSelected.png"); +} + +.trackCurvesButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackCurvesButtonDisabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackCurvesButtonDisabled@2x.png"); +} + +.trackCurvesButton:checked { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackCurvesButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackCurvesButtonEnabled@2x.png"); +} + +.Icon-Endmarker { + /* GUIState.textColor */ + color: rgb(57, 122, 234); +} + +.MarkerItem { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineMarkerItemCollapsed.png"); +} + +.MarkerItem:checked { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineMarkerItem.png"); +} + +.MarkerItem:hover:focus:checked { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineMarkerItemSelected.png"); +} + +.SignalEmitter { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineSignalCollapsed.png"); +} + +.SignalEmitter:checked { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TimelineSignal.png"); +} + +.SignalEmitter:hover:focus:checked { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineSignalSelected.png"); +} + +.trackCollapseMarkerButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackMarkerButtonDisabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackMarkerButtonDisabled@2x.png"); +} + +.trackCollapseMarkerButton:checked { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackMarkerButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackMarkerButtonEnabled@2x.png"); +} + +.Icon-ExtrapolationContinue { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineContinue.png"); +} + +.Icon-ExtrapolationHold { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineHold.png"); +} + +.Icon-ExtrapolationLoop { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineLoop.png"); +} + +.Icon-ExtrapolationPingPong { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelinePingPong.png"); +} + +.Icon-Foldout { + /* GUIState.background */ + background-image: resource("Builtin Skins/LightSkin/Images/IN foldout.png"); + + /* GUIState.scaledBackgrounds */ + -unity-scaled-backgrounds: resource("Builtin Skins/LightSkin/Images/IN foldout@2x.png"); +} + +/* GUIStyle.active */ +.Icon-Foldout:hover:active { + /* GUIState.background */ + background-image: resource("Builtin Skins/LightSkin/Images/IN foldout on.png"); + + /* GUIState.scaledBackgrounds */ + -unity-scaled-backgrounds: resource("Builtin Skins/LightSkin/Images/IN foldout on@2x.png"); +} + +/* GUIStyle.onActive */ +.Icon-Foldout:hover:active:checked { + /* GUIState.background */ + background-image: resource("Builtin Skins/LightSkin/Images/IN foldout on.png"); + + /* GUIState.scaledBackgrounds */ + -unity-scaled-backgrounds: resource("Builtin Skins/LightSkin/Images/IN foldout on@2x.png"); +} + +/* GUIStyle.onNormal */ +.Icon-Foldout:checked { + /* GUIState.background */ + background-image: resource("Builtin Skins/LightSkin/Images/IN foldout on.png"); + + /* GUIState.scaledBackgrounds */ + -unity-scaled-backgrounds: resource("Builtin Skins/LightSkin/Images/IN foldout on@2x.png"); +} + +.Icon-InfiniteTrack { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineInfiniteTrackNoShadow.png"); +} + +.Icon-Keyframe { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineKeyframe.png"); +} + +.trackLockOverlay { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineDisabledBackground.png"); +} + +.trackMuteButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackMuteButtonDisabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackMuteButtonDisabled@2x.png"); +} + +.trackMuteButton:checked { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackMuteButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackMuteButtonEnabled@2x.png"); +} + +.trackLockButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackLockButtonDisabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackLockButtonDisabled@2x.png"); +} + +.trackLockButton:checked { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackLockButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackLockButtonEnabled@2x.png"); +} + +.Icon-Options { + /* GUIState.background */ + background-image: resource("Icons/_Popup.png"); +} + +.Icon-PlayAreaEnd { + /* GUIState.textColor */ + color: rgba(255, 255, 255, 0.2); + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineEndPlayback.png"); +} + +.Icon-PlayAreaStart { + /* GUIState.textColor */ + color: rgba(255, 255, 255, 0.21); + + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineStartPlayback.png"); +} + +.Icon-Playrange { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelinePlayRange.png"); +} + +.Icon-TimeCursor { + /* GUIState.background */ + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/LightSkin/TimelineTimeCursor.png"); +} + +.Icon-TrackOptions { + /* GUIStyle.imagePosition */ + -unity-image-position: image-above; + + /* GUIState.background */ + background-image: resource("Builtin Skins/LightSkin/Images/pane options.png"); + + /* GUIState.scaledBackgrounds */ + -unity-scaled-backgrounds: resource("Builtin Skins/LightSkin/Images/pane options@2x.png"); +} + +.sequenceGroupFont { + /* GUIState.textColor */ + color: rgb(255, 255, 255); +} + +.Font-Clip { + /* GUIStyleState.textColor */ + color: rgb(0, 0, 0); +} + +.sequenceSwitcher{ + background-color: rgb(208, 208, 208); +} + +.trackButtonSuite { + background-color: rgba(241, 241, 241, 0.7); +} + +.markerHeaderMuteButton { + background-image: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackMuteButtonEnabled.png"); + -unity-scaled-backgrounds: resource("Packages/com.unity.timeline/Editor/StyleSheets/Images/Icons/TrackMuteButtonEnabled@2x.png"); +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/light.uss.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/light.uss.meta new file mode 100644 index 0000000000000000000000000000000000000000..8076cfcf9b1ce4b2df4868f1d31222ada09e2e43 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Extensions/light.uss.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e98085123be873947970c4f10099a39a +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0} + disableValidation: 1 diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images.meta new file mode 100644 index 0000000000000000000000000000000000000000..2988bc9fd82f059c38f31d7bb7e485715d459c7f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 5f603f10b9ec26841b2ecb6003dc1d0e +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin.meta new file mode 100644 index 0000000000000000000000000000000000000000..ba1aac181c2e2e4b60f39fe7aec553fff2fc2590 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 21b6b069ae021364ab45e1094807ec98 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineActivation.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineActivation.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..6b62a6be20f8f8222a01d44abd4d9db94b03856d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineActivation.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: 359cf58d5969d1a4aad29b095c7fc338 +timeCreated: 1484166676 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineAutokey.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineAutokey.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..e154a51e150eba81218f4b5798095c18f0dab5f5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineAutokey.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 92b5e4310629b264dad0fb2cc196d818 +timeCreated: 1460382690 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineAutokey@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineAutokey@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..43f7f107addc39c123e5e5f29a70b83fdd2d854c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineAutokey@2x.png.meta @@ -0,0 +1,91 @@ +fileFormatVersion: 2 +guid: af24c542434a025448222d576f61a956 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineAutokey_active.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineAutokey_active.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..7b0ee04f1081bc203d9f19f96176af7c1e4c7e4a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineAutokey_active.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: e17ee60887efdd04389991a15ee0c578 +timeCreated: 1465396246 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 64 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 64 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineAutokey_active@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineAutokey_active@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..3587ec0c9c4eb69827879ca5d12952da3c4de33f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineAutokey_active@2x.png.meta @@ -0,0 +1,91 @@ +fileFormatVersion: 2 +guid: 183f7b7549219ab47becb461a16df882 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineContinue.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineContinue.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..0fc876e112888e35d680439c2ffecf1ae6bb0af8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineContinue.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: f747f9cdf03f2ff418fe728a77e8cbef +timeCreated: 1481652765 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineDisabledBackground.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineDisabledBackground.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..35c87a04d5bb593fa5076d2b2720f0ded656a110 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineDisabledBackground.png.meta @@ -0,0 +1,119 @@ +fileFormatVersion: 2 +guid: 412f73153f3a3c549b67b2a847741145 +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 1 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + vertices: [] + indices: + edges: [] + weights: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineEndPlayback.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineEndPlayback.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..7a164527a2d90db56471d713a25f003b8b9cd55f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineEndPlayback.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: c285802d9d414814fad592b90b223f15 +timeCreated: 1454598165 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineHold.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineHold.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..020bbf7aa18371fc4cdd68302c3b6e37da7216e3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineHold.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: ddbd45249a133a846b2f20e39b537565 +timeCreated: 1481653109 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineIconClipIn.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineIconClipIn.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..10b77693862c04ecc6034aeb0cd805f7cb59661b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineIconClipIn.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: ab1e2f0dfb0df5e40bb95359b3d8ed3a +timeCreated: 1480536694 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineIconClipOut.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineIconClipOut.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..171dbffa931f5bf6c57d37689415d95caea536e3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineIconClipOut.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 32f7e3598d6414c489127629e29af3f6 +timeCreated: 1480535436 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineInfiniteTrackNoShadow.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineInfiniteTrackNoShadow.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..f0afba35e820025e354889300dafdc20f7f1052e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineInfiniteTrackNoShadow.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: eae63adb172f1164db61a7f4bdfc3637 +timeCreated: 1484150287 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineKeyframe.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineKeyframe.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..f1c44aaa468651e8cbaf24a71bae61dbb31c37b4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineKeyframe.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: 8eba099eb091faf419fecdcd5cdabfd7 +timeCreated: 1484066929 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineLoop.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineLoop.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..8ef01176060f94aae3c1a401dff9f68fd31f8ecc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineLoop.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: 360dded8761e81d4d98c10f469d55492 +timeCreated: 1481653109 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineMarkerItem.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineMarkerItem.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..ce24d1e7e6a6b627d298b4cee572ef2158f30f82 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineMarkerItem.png.meta @@ -0,0 +1,90 @@ +fileFormatVersion: 2 +guid: c133595e3c100774496e03e66fa69259 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 8 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineMarkerItemCollapsed.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineMarkerItemCollapsed.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..4b3377887c81244ee50ce4c5a0616aecc265f2dc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineMarkerItemCollapsed.png.meta @@ -0,0 +1,90 @@ +fileFormatVersion: 2 +guid: f179d9a3cccffb04ba2e27f681e9b147 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 8 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineMarkerItemSelected.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineMarkerItemSelected.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..dd4b4fd04e88e4b176923ee8bcd35aca3481515f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineMarkerItemSelected.png.meta @@ -0,0 +1,90 @@ +fileFormatVersion: 2 +guid: 3dd65256ca8837544b3e738c0d3ee0e2 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 8 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelinePingPong.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelinePingPong.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..5dc471db8dc41885aa694dbeeb26ca05b29e5b5c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelinePingPong.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: d3b5c4f7d6b94f64085b3713bffa680e +timeCreated: 1481580507 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelinePlayRange.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelinePlayRange.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..8ace41d94a0d3525a7594fcb21b8f730c8248ed4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelinePlayRange.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 43eeff8a446b32242a4fb1a5c1bd7b8e +timeCreated: 1481916753 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineSignalCollapsed.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineSignalCollapsed.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..38f8402bf54d5dae6380cd8d4842d1551d6b7fe3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineSignalCollapsed.png.meta @@ -0,0 +1,83 @@ +fileFormatVersion: 2 +guid: d91793cd853a258448e4d5545bb38e45 +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + vertices: [] + indices: + edges: [] + weights: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineSignalSelected.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineSignalSelected.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..c8250dcaba7c70ebe263c35193f983ab50db7483 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineSignalSelected.png.meta @@ -0,0 +1,88 @@ +fileFormatVersion: 2 +guid: a5e21f4e466690645980dd0cf0b664bc +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 7 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + vertices: [] + indices: + edges: [] + weights: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineStartPlayback.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineStartPlayback.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..2f8fc735fbe51b4fafb5594e9d2834a4567461fd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineStartPlayback.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 5060c9f9eb2f7ee4695b638a21d8fe01 +timeCreated: 1454598165 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineTimeCursor.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineTimeCursor.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..0c8ec5ec932078ffe9cef0c01ed76994f7b0c6e3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/DarkSkin/TimelineTimeCursor.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 3b9e9b3d9ade166499e7a17109ca73bf +timeCreated: 1454538902 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons.meta new file mode 100644 index 0000000000000000000000000000000000000000..3c0bfbd929c1d47c6916d6cbaf5be15036168714 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: a90603761ea3d8449a60aebebd202228 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/Timeline-Marker-Warning-Overlay.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/Timeline-Marker-Warning-Overlay.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..1852412111be4d25f5251b30149b2c35ecf38727 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/Timeline-Marker-Warning-Overlay.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 945f4ecec6df62244b9ebcc363833642 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 9 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: -1 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineClipBG.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineClipBG.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..18a0bb3f4745a59e3c2b70a75faf674a5d150144 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineClipBG.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: d44fc8b11425e0043aa7c20a301ce707 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: -100 + wrapU: 0 + wrapV: 0 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineClipFG.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineClipFG.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..3e9cce0fd0e12ce73541db3d60436019d0d024e9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineClipFG.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 33b1871a2d09cfa459a93f4e8feb5c41 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: -100 + wrapU: 0 + wrapV: 0 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineCollapseMarkerButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineCollapseMarkerButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..6d59f4b69b700873c4498ca98dc7e9fa2e0557d6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineCollapseMarkerButtonDisabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: b80d5b6acdfbc114b9efab6295fd96c1 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineCollapseMarkerButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineCollapseMarkerButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..bb0095c214c75fd2f5e3cafb561e41c3d3c60d10 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineCollapseMarkerButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 0367ce1ebbbb18940b79eed63a0315d5 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineDigIn.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineDigIn.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..21f34335c54bb4157ae1c3d7ea5e4ca931e59443 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineDigIn.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: b1d064d6d80829f4eb370f679384ea1f +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: -100 + wrapU: 0 + wrapV: 0 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeMixOFF.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeMixOFF.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..5c66a0e666ebdc2deae8c5daaf2350b6e62f227b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeMixOFF.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 8fca5ed160cdc5440a4c7561db4082b2 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeMixON.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeMixON.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..37bf9e157dfbf7c290913a2eca42b58ec4ed7efa --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeMixON.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: a82846d41464fcf4b962ebdc815963f5 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeReplaceOFF.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeReplaceOFF.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..33ca3ae2e79810c806beee60d1dfa97f1804e25a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeReplaceOFF.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 09ae14686a02d484ab41e76fd1efba14 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeReplaceON.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeReplaceON.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..a896acc66424d19f3cfc9958bc4138fcbc50d2fe --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeReplaceON.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 6d41c3e8796a4fd4e80840354039e4ac +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeRippleOFF.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeRippleOFF.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..8f4958c7e4d559e02f757785159b6f2ab834d6b3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeRippleOFF.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: bd7b7cac6eb0c3f469781d9a729a1c94 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeRippleON.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeRippleON.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..514ab7abaa43312cb63cc039a1b3de24a3b1f8fd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineEditModeRippleON.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: c5c1f094d9a9b3f4c9cc6c3a87af871c +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineHeaderMarkerIcon.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineHeaderMarkerIcon.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..0d0792447767745eb7b907a88c7a1f19917ba152 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineHeaderMarkerIcon.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: bf1debab21103154b99778ba6e074175 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineSelector.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineSelector.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..469f273086b3fda3c6db6ecbabc976ed1472d20a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineSelector.png.meta @@ -0,0 +1,139 @@ +fileFormatVersion: 2 +guid: 73f5ebb64da7b2a40ab6bffac80f1a61 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 1 + - serializedVersion: 3 + buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 1 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineSignal.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineSignal.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..bc8bc1b06a504e70fdba4bffb78a7c4776dfbe0c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TimelineSignal.png.meta @@ -0,0 +1,88 @@ +fileFormatVersion: 2 +guid: 15845fb26c2846947b4dedb9fb348cc1 +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 7 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + vertices: [] + indices: + edges: [] + weights: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackAvatarButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackAvatarButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..ceb36b26eece79c0d80b1a1c30526cf79b62347c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackAvatarButtonDisabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 54623075676bd504d93243fb18745161 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackAvatarButtonDisabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackAvatarButtonDisabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..e47a752407cb98e27947ad4d97df8c89c4f97604 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackAvatarButtonDisabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 7c05578092876a0458b8b480269aef86 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackAvatarButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackAvatarButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..73ce9fea803cd7c851bfc0a08455efba42109914 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackAvatarButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 4bf6507f1346b2746a35384f6a5fd5f9 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackAvatarButtonEnabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackAvatarButtonEnabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..9311de7749c84851fb144c8c160d38726f8f269b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackAvatarButtonEnabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 51bf5f55a8a01e546bf6092b54fdae20 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackCurvesButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackCurvesButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..ad59a9bf2ec174c312a639ba3615710065b9f9f9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackCurvesButtonDisabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: f0f8ff8921b22a74a8c79d955ace248d +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 1 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackCurvesButtonDisabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackCurvesButtonDisabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..ed01566b50a8028f24423fa4aeee9efd4f3c6d58 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackCurvesButtonDisabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: a383d8b1327c9254896ad76d6efaf357 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackCurvesButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackCurvesButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..875e3b4603f5f47e4cc680da007892bd9afd7085 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackCurvesButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 9589d5d9eb09dec43b2ad51af4e78b1e +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackCurvesButtonEnabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackCurvesButtonEnabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..9fa1cce550559827a1f19905277240d3b65bf3d2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackCurvesButtonEnabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 9e541b6dcfb77d34481f69b3d62d0343 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackLockButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackLockButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..ca6d1cd64ebc18b94cbc3c0bb2b0711456f2ea0e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackLockButtonDisabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: fef7487d8b06bba408f70354e2463ce4 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackLockButtonDisabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackLockButtonDisabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..f4d7353044a1c4a9dfea1a7bbf760a11ef60d32f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackLockButtonDisabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 6fb5cabb85ba3794682b16eba19440cb +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackLockButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackLockButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..be16e31a73d10aeb92f7dd147592d3fde5a0f229 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackLockButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: cf575301f1e76c4478de0e77db15eba0 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackLockButtonEnabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackLockButtonEnabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..7d590aa3a44f6a5e8bab7804281223c03b275d02 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackLockButtonEnabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: b8c531b4e51e4994a81837c4e9b0d649 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMarkerButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMarkerButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..cabf9265f92029feb7af6f55c8e8d5feb76f7339 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMarkerButtonDisabled.png.meta @@ -0,0 +1,117 @@ +fileFormatVersion: 2 +guid: 33a52b41b4de5874ca7da1da32067e39 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMarkerButtonDisabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMarkerButtonDisabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..c9d760f09fe7c54ef6676d4fe43c033dff7015fb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMarkerButtonDisabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 193dae938a3136440b693b45a2494737 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMarkerButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMarkerButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..12ab079a1615fe9fba23f8d30c845fb3e436e624 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMarkerButtonEnabled.png.meta @@ -0,0 +1,117 @@ +fileFormatVersion: 2 +guid: d1eccbb425fdacc4ba53ce4223f4ea30 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMarkerButtonEnabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMarkerButtonEnabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..40f50c7b61a4b19a6e55b8e9d2968517da3bf754 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMarkerButtonEnabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: c35a22ede3f5feb488bf69587ddc36ed +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMuteButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMuteButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..9e1a1b7209e407009fc06a38b0c7b1c29fa7d579 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMuteButtonDisabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 5216b1b48296ef345ad2d2ec43105bf0 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMuteButtonDisabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMuteButtonDisabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..377f4afaab1f6934e007bddd15e8736a2945b0fd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMuteButtonDisabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: db31466324572e740a431e4e0e03a016 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMuteButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMuteButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..443db176800b547561bc54486dfc25e5d06b4803 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMuteButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 81e8b4a4bcbf7a14898e2658fd827642 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMuteButtonEnabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMuteButtonEnabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..f78c8149dd6a24c0da5d729ce050c7e320513f70 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackMuteButtonEnabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 512aaee9b220348408a2e518f98d6e14 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackRecordButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackRecordButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..efe218db54ab91a80a5b8e8def17b78c8eb872c7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackRecordButtonDisabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 495998c718a094540bbe57ae5ab07647 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackRecordButtonDisabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackRecordButtonDisabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..ccc6d969c7e6550b83cfa796b3493126d84fe8b4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackRecordButtonDisabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 6091f9516d23100479c03bca26138bc8 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackRecordButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackRecordButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..9c2a34ad4f0af61ea639f2cfb09065c777cf2336 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackRecordButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: c6a0c6226c05f954fa6cd03aebb4d255 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackRecordButtonEnabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackRecordButtonEnabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..2310b940d43adc9bebabab976f0791bd89134369 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/TrackRecordButtonEnabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 8fdae4ac756ed6047b01021ff0cc3ebb +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineCollapseMarkerButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineCollapseMarkerButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..6d53ef215c42dd24e2b8262621218987b16f9499 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineCollapseMarkerButtonDisabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 40947ddc2dd4f0d499a92d0f3675c4e8 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 1 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineCollapseMarkerButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineCollapseMarkerButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..cc20436f80662bf109545cc50faf4d1a94449f0f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineCollapseMarkerButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 2446ee609b613cd4e9142ccc55cb7c43 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineDigIn.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineDigIn.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..fb86cad784df390bfd4365fd652151d18d15d820 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineDigIn.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 22c3c381bd3cd4a40a8541103023e1ef +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeMixOFF.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeMixOFF.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..66cb896616dbacab4ce4434c3276eea6676826e3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeMixOFF.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 39d9575ed0465354cb02b69ea18526de +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeMixON.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeMixON.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..b42e3670c77eee1ca327808411b6e4cb0db4cc81 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeMixON.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 7c681ffb5a436684fa3e98a9b66775c0 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeReplaceOFF.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeReplaceOFF.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..287012e7a0bcbb7e8e973cdb177c4ef02a9e3684 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeReplaceOFF.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 912fd71cbf4cbe140b4f240bedbc1f3e +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeReplaceON.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeReplaceON.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..1bced0310a240b0047ba36674556a72f3bc4435c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeReplaceON.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 7b4b3cedf598c954cb2f38d6e2e34c0d +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeRippleOFF.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeRippleOFF.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..d350e3aa1833d80f03013c61d44483699b3113a9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeRippleOFF.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 411e6f19c19fa0546af83aeb59c2ed4b +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeRippleON.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeRippleON.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..ec7afb85dcf036e7aa891d435f7abec6bab1490e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineEditModeRippleON.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 67a774c4384aa6c488128e2851b18ced +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineHeaderMarkerIcon.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineHeaderMarkerIcon.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..d947cf0eb9288d43d8adb80bebefe1889ff82272 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineHeaderMarkerIcon.png.meta @@ -0,0 +1,115 @@ +fileFormatVersion: 2 +guid: 4f8d98ef7dbbe3d469e14c04722cbeed +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineSelector.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineSelector.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..64a463b2daf542d4c8c1e214b18df7627dac2453 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineSelector.png.meta @@ -0,0 +1,139 @@ +fileFormatVersion: 2 +guid: 06bf6150656339941aa98e175a995445 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 0 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 1 + - serializedVersion: 3 + buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 1 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineSignal.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineSignal.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..6069c308f3004db6dcefd1b58ec01ff1a483071a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TimelineSignal.png.meta @@ -0,0 +1,88 @@ +fileFormatVersion: 2 +guid: ad2e3e92b00839c4e991ca602ef19822 +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 7 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + vertices: [] + indices: + edges: [] + weights: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..218015e053746474d9cfd86945611ede1808c1ac --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonDisabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 91746a504b59769439bb2749c314d231 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonDisabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonDisabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..dff7f6bb7ea6fcb063fa5aa864fab84a5ea701c4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonDisabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: fd194f75fe3d7ca4488fa775ae832fd8 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..e0e8cc62da5fde5a1d1444924bc7897db50fa70b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: c207dcd389fb689489f5266468cd4609 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonEnabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonEnabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..c207c32b346a23182dc67f2f00a267ffa9dfaa33 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackAvatarButtonEnabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: fd12dbe3b63ae464f824b4a74c0e1766 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..3098cbba44ff132128e7d2327670dc9abcd10b2a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonDisabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: d55a54a15106e3f418a43134888f2211 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonDisabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonDisabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..90d4391c47253f5ee188222fe9ece887ffacbe1e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonDisabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 1f3ea4caa6e0ec74388e4d7d16690e68 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..014f29c04f8f7e59b252ba31f59be29118e2cee7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: fbcdeb07ee516a64daa01ce462874280 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonEnabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonEnabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..93f530832a67a3fb6a8acce83bb577bca0334d7a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackCurvesButtonEnabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 43ed4593c5ddda0439fcc1bdaf8309fe +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackLockButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackLockButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..d824433dca1c2b3d984d0eb8fc279fbddbac3a84 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackLockButtonDisabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 52ee3ba2abc3da14a95cdf64d32ae0ae +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackLockButtonDisabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackLockButtonDisabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..e9c5a56f47cec9c74184656efccaaa6310d0cec7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackLockButtonDisabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 6f0b77e050cdb12478ed9514b3a0e40e +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackLockButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackLockButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..12449da49764c81a3204a282707c54306b027b91 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackLockButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: e8aa120f1b4731e43a2dd31eb70bbbe2 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackLockButtonEnabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackLockButtonEnabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..296dcad3ccba0e998ac149af98b909a80148e713 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackLockButtonEnabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 2c85066ea99cfbe4f90294bf295ce543 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..4b828bf0e5a184f709e52af83565cb5632aa5f07 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonDisabled.png.meta @@ -0,0 +1,117 @@ +fileFormatVersion: 2 +guid: b3644a971cca0bd4eb357cb9aca4dde1 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonDisabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonDisabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..27d840339a76cb2ca9ec8040f775d4c28752759b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonDisabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 77d926c9a4ddcc940b8c000b45cbfb35 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..14f236cf407543eead7249d8a64b47cbe4bec69b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: d18286874382ef042bbbdab5f71329c1 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonEnabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonEnabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..241b5431bb2a1c02ff32af71e4ed4c1a627d5bcc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMarkerButtonEnabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 6192986415256ca47a97a97507406f5e +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..2664d0a5ef77c2ef9c050316e6e7034e1e3fcee8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonDisabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 6ab002208ec290544b44bc263dc58a95 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonDisabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonDisabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..41ef67326d58f7080b95367c82f43c16aae5ad71 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonDisabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 9c706019afb28944eb19b500ea0da38c +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..f65eaeba78199941c25b8da2bd59ac1df400ea3e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: ac5017dfbeee42347b3b45ecc572674e +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonEnabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonEnabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..2b9af786fb238e2581f00b28a36cd014bec8d5fd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackMuteButtonEnabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: e54e20c7a9730fe4c822d63228527ae4 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonDisabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonDisabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..c3ef722d24ce753d7359327629ab40485a1a05aa --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonDisabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 9c6daec86666cbb4b9e558b839a103db +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonDisabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonDisabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..1f26a4f877ffe671518f5f855126e835c0efb945 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonDisabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: db15c78579dee4a4db85f392634c8ecc +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonEnabled.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonEnabled.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..34e9edc212283913418601846355251b9add4b38 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonEnabled.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 0e5ba0f04df278944a8f5a62f64f5aa6 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonEnabled@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonEnabled@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..5f90323fc8b0b0fcd361bcf9d1632b6271ffa608 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Icons/d_TrackRecordButtonEnabled@2x.png.meta @@ -0,0 +1,105 @@ +fileFormatVersion: 2 +guid: 0f1c9a12872a30f45bab34f536332bb3 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: -1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 2 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin.meta new file mode 100644 index 0000000000000000000000000000000000000000..e08f364a50f5d15224fef629aac5c8281a344a5b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 8ad9b938ad733e94ca95fe5a5c19a5b8 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineActivation.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineActivation.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..a136318f86fa229ae6c81a149e921ca81594c7e7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineActivation.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: 2887294cc7f1fe840bff6e349409648d +timeCreated: 1484165733 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineAutokey.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineAutokey.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..6063498ea483fd835a5fecb0a17e1788139062fb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineAutokey.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: af3aec622aef40c45813b39e405966a3 +timeCreated: 1463497119 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineAutokey@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineAutokey@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..7049d7dec6d911a77352597c0926e9bba822bcb0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineAutokey@2x.png.meta @@ -0,0 +1,91 @@ +fileFormatVersion: 2 +guid: cf3fbf98d5c3f1941bd9c0256918a4c8 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineAutokey_active.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineAutokey_active.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..42bf09bb6e2bd6711493d655a0a532e469ae64ae --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineAutokey_active.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 0a5e3e063c4e1ab45999cf6e40c13c07 +timeCreated: 1463497122 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineAutokey_active@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineAutokey_active@2x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..41ace44a75c32cb115f1f4165e97b909b6cf9803 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineAutokey_active@2x.png.meta @@ -0,0 +1,91 @@ +fileFormatVersion: 2 +guid: f6717d61970edba4686c297677881a77 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineContinue.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineContinue.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..ee71da0499f6ff96eba8ee3a9bc2a82c415ca2aa --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineContinue.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: 61c21f74972ba8246b3ea400a9231841 +timeCreated: 1481657337 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineDisabledBackground.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineDisabledBackground.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..555c102d7f26a43e4087d8e9bfddbec911a48967 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineDisabledBackground.png.meta @@ -0,0 +1,119 @@ +fileFormatVersion: 2 +guid: 0304baf8d224f3e47b22d872c8dcd412 +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + vertices: [] + indices: + edges: [] + weights: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineEndPlayback.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineEndPlayback.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..c6b3b5ce8ed3a876563e6e0f39921e2e1215aa3a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineEndPlayback.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 6952cd3b0f88917449a8fa4d19fc5009 +timeCreated: 1463497108 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineHold.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineHold.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..8a5eafeaaf7700ce21ce9840c4eb65677f9da76d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineHold.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: a09fd8b5d9396c24a96a6de50cddc3b9 +timeCreated: 1481652201 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineIconClipIn.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineIconClipIn.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..47909c6daa82a3a4e40b1ac30dfc57a04e872e84 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineIconClipIn.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: 4171b549947246b4f9579419d5698a7e +timeCreated: 1481402454 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineIconClipOut.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineIconClipOut.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..925d98f1335cde0d85f4759304296c1aef1a7c3a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineIconClipOut.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: a7a968b204ed77c4ba90be3ef3ee8551 +timeCreated: 1481569020 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineInfiniteTrackNoShadow.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineInfiniteTrackNoShadow.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..fb8bb821b14d76e770523837db43c2249f9bd03d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineInfiniteTrackNoShadow.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: 69ff79f863a32ad44a9497d4896d9d1c +timeCreated: 1484066142 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineKeyframe.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineKeyframe.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..d8f5c945cc9d72fb643061973667a5db0092474d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineKeyframe.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: f9fd2f335364cda41937eab39bf20049 +timeCreated: 1484152109 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineLoop.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineLoop.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..0881676ba0ebe449db4e274a2f09d4cc6c93c0c4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineLoop.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: c7df1e797b21c774f9b859d17f674737 +timeCreated: 1481580507 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineMarkerItem.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineMarkerItem.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..148ffa6807a3eab953e2e2b5790de732c206d28b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineMarkerItem.png.meta @@ -0,0 +1,90 @@ +fileFormatVersion: 2 +guid: 24b97c67b63a23b48bea4036d28a5818 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 8 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineMarkerItemCollapsed.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineMarkerItemCollapsed.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..cb71cdc2e4dc7f35dfb2d8a2e15df3772c3d4248 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineMarkerItemCollapsed.png.meta @@ -0,0 +1,90 @@ +fileFormatVersion: 2 +guid: 7d4691eba7565c34ab785c00fbc27ff8 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 8 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineMarkerItemSelected.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineMarkerItemSelected.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..041863ed8850231ccde61578dc786a57f115bca6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineMarkerItemSelected.png.meta @@ -0,0 +1,90 @@ +fileFormatVersion: 2 +guid: b6e9dc9aad5843748a0124b8925c3743 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 8 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelinePingPong.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelinePingPong.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..35ec4788c057e6e2bcba2dece2dbb365137c3f40 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelinePingPong.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 88d697f38121de443ba144702e5122d9 +timeCreated: 1481580508 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelinePlayRange.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelinePlayRange.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..b54c1d3d97ef04a2226c296a099fdc9903d8d804 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelinePlayRange.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 70e3f118652b9094885689730ad3a47b +timeCreated: 1481916753 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineSignalCollapsed.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineSignalCollapsed.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..76f21aaa7315bdb01596d82021f78a25d861c644 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineSignalCollapsed.png.meta @@ -0,0 +1,86 @@ +fileFormatVersion: 2 +guid: a88fa20ed164bbe4da6bf533f94a3113 +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 6 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + vertices: [] + indices: + edges: [] + weights: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineSignalSelected.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineSignalSelected.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..4a943b6995de845e5417732de93db8defa85580c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineSignalSelected.png.meta @@ -0,0 +1,88 @@ +fileFormatVersion: 2 +guid: 1a7852b1b33b816498b6af1e739f5995 +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 7 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + vertices: [] + indices: + edges: [] + weights: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineStartPlayback.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineStartPlayback.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..fb58b3ff1e4ba58033cc2d106ad0c0cf6818ff80 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineStartPlayback.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 824c4beb0ca6c934bbc7a26919302236 +timeCreated: 1463497128 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineTimeCursor.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineTimeCursor.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..f37e3609ae339389bee86acaae6c3423fa82438b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/LightSkin/TimelineTimeCursor.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: ed665472b4fee2043a5c1cc802beaa8e +timeCreated: 1463497119 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared.meta new file mode 100644 index 0000000000000000000000000000000000000000..d15a1751a27b8cda6317dcb05dc80a672e8c6ed0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 456d458547ae36d44a13d4a4682f0441 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/Timeline-Marker-Multi-Overlay.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/Timeline-Marker-Multi-Overlay.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..50d79108dce97b8fb5244905cec53d6cde700b31 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/Timeline-Marker-Multi-Overlay.png.meta @@ -0,0 +1,108 @@ +fileFormatVersion: 2 +guid: 75f26f1c549568c4e9950a368bd08cb8 +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 6 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + vertices: [] + indices: + edges: [] + weights: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineBottomShadow.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineBottomShadow.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..20be770cb526bfa2e3e75ba96e5122989a125d14 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineBottomShadow.png.meta @@ -0,0 +1,117 @@ +fileFormatVersion: 2 +guid: db66ea47c76423f4a881937d34495801 +timeCreated: 1479917874 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineConnector.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineConnector.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..44f822be29ded83782f8a9422f5478af107a7994 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineConnector.png.meta @@ -0,0 +1,107 @@ +fileFormatVersion: 2 +guid: a04f1625bf500f64e97445265dfbcc93 +timeCreated: 1481569141 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineDisplay.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineDisplay.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..943c1c5ad86b820f72f15cdfa93b06225718367e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineDisplay.png.meta @@ -0,0 +1,104 @@ +fileFormatVersion: 2 +guid: 03ae22b9de3989144a9bebf8972b4fad +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineGroupBackground.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineGroupBackground.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..63f28fced44f408cea191160acf64b7f12704fbc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineGroupBackground.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 6ca5daa3415451940921fa7e2c3db9e8 +timeCreated: 1434467611 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: -1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineOutline.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineOutline.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..2c8f4d0c3bd8fbba94fe2e28a77ba29442275c7d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineOutline.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 829511f8e35bf3a40be037a1050f801c +timeCreated: 1461591699 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineSeqEnd.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineSeqEnd.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..512379faf8bccdcfabe6d056770d8bff17e5be52 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineSeqEnd.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 5dfe66e61e0d270468ae75349ff3a3eb +timeCreated: 1455898819 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineSwatch.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineSwatch.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..a350aa4476e48b8bb947483a3f64bc3c1e46ba2d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineSwatch.png.meta @@ -0,0 +1,117 @@ +fileFormatVersion: 2 +guid: e50018fd67fc156459e4014bdad3f5f6 +timeCreated: 1476817131 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: tvOS + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineWarning.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineWarning.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..5b266db86307e7df4ae380ce228afdfe6958a9d3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/Images/Shared/TimelineWarning.png.meta @@ -0,0 +1,77 @@ +fileFormatVersion: 2 +guid: 1732e542f535d374bbfa7565fc78414e +timeCreated: 1455644730 +licenseType: Pro +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 5 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 1 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 5 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 0 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res.meta new file mode 100644 index 0000000000000000000000000000000000000000..1ef39f834d630267f0a3d219a7620b63e9e5c756 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 12a2d6aa8a743f04aa760f8c675c97e6 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/HumanoidDefault.anim b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/HumanoidDefault.anim new file mode 100644 index 0000000000000000000000000000000000000000..ba787ebec49e335ea092bfabd6df076425ef32a8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/HumanoidDefault.anim @@ -0,0 +1,6683 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!74 &7400000 +AnimationClip: + m_ObjectHideFlags: 0 + m_PrefabParentObject: {fileID: 0} + m_PrefabInternal: {fileID: 0} + m_Name: HumanoidDefault + serializedVersion: 6 + m_Legacy: 0 + m_Compressed: 0 + m_UseHighQualityCurve: 0 + m_RotationCurves: [] + m_CompressedRotationCurves: [] + m_EulerCurves: [] + m_PositionCurves: [] + m_ScaleCurves: [] + m_FloatCurves: + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.0023206125 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.0023206125 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootT.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.9978025 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.9978025 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootT.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.0036914505 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.0036914505 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootT.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.0009904206 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.0009904206 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootQ.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.000000029802322 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.000000029802322 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootQ.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.000000029802322 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.000000029802322 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootQ.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.9999995 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.9999995 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootQ.w + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.09074765 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.09074765 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootT.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.99597967 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.99597967 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootT.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.032569747 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.032569747 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootT.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootQ.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.4995045 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.4995045 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootQ.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootQ.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.49950463 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.49950463 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootQ.w + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.08610656 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.08610656 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootT.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.99597967 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.99597967 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootT.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.03256977 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.03256977 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootT.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootQ.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.49950442 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.49950442 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootQ.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootQ.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.4995047 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.4995047 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootQ.w + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.6962602 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.6962602 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandT.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.39508566 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.39508566 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandT.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.029317556 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.029317556 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandT.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.0011194708 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.0011194708 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandQ.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.028612569 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.028612569 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandQ.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.99959004 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.99959004 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandQ.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.000031995765 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.000031995765 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandQ.w + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6916188 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6916188 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandT.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.39508596 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.39508596 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandT.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.029317655 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.029317655 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandT.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.02861254 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.02861254 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandQ.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.0011195474 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.0011195474 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandQ.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.000032021475 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.000032021475 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandQ.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.99959004 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.99959004 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandQ.w + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Spine Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Spine Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Spine Twist Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Chest Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Chest Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Chest Twist Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 1.6044449e-22 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 1.6044449e-22 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: UpperChest Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 2.0281193e-14 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 2.0281193e-14 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: UpperChest Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 3.1805545e-15 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 3.1805545e-15 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: UpperChest Twist Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.21768919 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.21768919 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Neck Nod Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.0000005364417 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.0000005364417 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Neck Tilt Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -2.5518072e-15 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -2.5518072e-15 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Neck Turn Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.1385466 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.1385466 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Head Nod Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.0000005064527 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.0000005064527 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Head Tilt Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.0000002003913 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.0000002003913 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Head Turn Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Eye Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Eye In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Eye Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Eye In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 1.0285543 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 1.0285543 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Jaw Close + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.0000021457988 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.0000021457988 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Jaw Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.5288592 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.5288592 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Upper Leg Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.00000017935282 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.00000017935282 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Upper Leg In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.000000071362784 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.000000071362784 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Upper Leg Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.93421274 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.93421274 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Lower Leg Stretch + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00000023841858 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00000023841858 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Lower Leg Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.03387608 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.03387608 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Foot Up-Down + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00000055896726 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00000055896726 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Foot Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -1.4463487e-29 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -1.4463487e-29 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Toes Up-Down + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.5288592 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.5288592 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Upper Leg Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.000000049938695 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.000000049938695 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Upper Leg In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00000008376336 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00000008376336 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Upper Leg Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.93421274 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.93421274 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Lower Leg Stretch + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Lower Leg Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.03387639 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.03387639 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Foot Up-Down + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00000034893546 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00000034893546 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Foot Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Toes Up-Down + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.6577008 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.6577008 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Shoulder Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.026656672 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.026656672 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Shoulder Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.5008309 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.5008309 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Arm Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.2945701 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.2945701 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Arm Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00094974384 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00094974384 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Arm Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.89037263 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.89037263 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Forearm Stretch + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.0039196364 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.0039196364 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Forearm Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00038705475 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00038705475 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Hand Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.24678716 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.24678716 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Hand In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.65770036 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.65770036 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Shoulder Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.026655924 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.026655924 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Shoulder Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.5008307 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.5008307 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Arm Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.29456997 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.29456997 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Arm Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00094974646 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00094974646 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Arm Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8903728 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8903728 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Forearm Stretch + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.0039196513 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.0039196513 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Forearm Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00038712102 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00038712102 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Hand Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.24678724 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.24678724 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Hand In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.7149313 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.7149313 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Thumb.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.37668565 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.37668565 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Thumb.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.64628243 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.64628243 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Thumb.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.64628184 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.64628184 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Thumb.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Index.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.45739162 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.45739162 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Index.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Index.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Index.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Middle.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.61083114 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.61083114 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Middle.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Middle.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Middle.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.66797 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.66797 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Ring.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.6108282 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.6108282 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Ring.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Ring.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Ring.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Little.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.45739284 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.45739284 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Little.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Little.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Little.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.71493024 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.71493024 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Thumb.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.37669381 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.37669381 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Thumb.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6462818 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6462818 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Thumb.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.64628184 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.64628184 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Thumb.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Index.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.45739165 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.45739165 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Index.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Index.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Index.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Middle.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.6108283 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.6108283 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Middle.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Middle.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Middle.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Ring.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.61083126 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.61083126 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Ring.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Ring.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Ring.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Little.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.45739275 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.45739275 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Little.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116837 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116837 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Little.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Little.3 Stretched + path: + classID: 95 + script: {fileID: 0} + m_PPtrCurves: [] + m_SampleRate: 30 + m_WrapMode: 0 + m_Bounds: + m_Center: {x: 0, y: 0, z: 0} + m_Extent: {x: 0, y: 0, z: 0} + m_ClipBindingConstant: + genericBindings: + - serializedVersion: 2 + path: 0 + attribute: 7 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 8 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 9 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 10 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 11 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 12 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 13 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 14 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 15 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 16 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 17 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 18 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 19 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 20 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 21 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 22 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 23 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 24 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 25 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 26 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 27 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 28 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 29 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 30 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 31 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 32 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 33 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 34 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 35 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 36 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 37 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 38 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 39 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 40 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 41 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 42 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 43 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 44 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 45 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 46 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 47 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 48 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 49 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 50 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 51 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 52 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 53 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 54 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 55 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 56 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 57 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 58 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 59 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 60 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 61 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 62 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 63 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 64 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 65 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 66 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 67 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 68 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 69 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 70 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 71 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 72 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 73 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 74 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 75 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 76 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 77 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 78 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 79 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 80 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 81 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 82 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 83 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 84 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 85 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 86 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 87 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 88 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 89 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 90 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 91 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 92 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 93 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 94 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 95 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 96 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 97 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 98 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 99 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 100 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 101 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 102 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 103 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 104 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 105 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 106 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 107 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 108 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 109 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 110 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 111 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 112 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 113 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 114 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 115 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 116 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 117 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 118 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 119 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 120 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 121 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 122 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 123 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 124 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 125 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 126 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 127 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 128 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 129 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 130 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 131 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 132 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 133 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 134 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 135 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + - serializedVersion: 2 + path: 0 + attribute: 136 + script: {fileID: 0} + typeID: 95 + customType: 8 + isPPtrCurve: 0 + pptrCurveMapping: [] + m_AnimationClipSettings: + serializedVersion: 2 + m_AdditiveReferencePoseClip: {fileID: 0} + m_AdditiveReferencePoseTime: 0 + m_StartTime: 0 + m_StopTime: 0.033333335 + m_OrientationOffsetY: 0 + m_Level: 0 + m_CycleOffset: 0 + m_HasAdditiveReferencePose: 0 + m_LoopTime: 0 + m_LoopBlend: 0 + m_LoopBlendOrientation: 0 + m_LoopBlendPositionY: 0 + m_LoopBlendPositionXZ: 0 + m_KeepOriginalOrientation: 0 + m_KeepOriginalPositionY: 1 + m_KeepOriginalPositionXZ: 0 + m_HeightFromFeet: 0 + m_Mirror: 0 + m_EditorCurves: + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.0023206125 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.0023206125 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootT.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.9978025 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.9978025 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootT.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.0036914505 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.0036914505 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootT.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.0009904206 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.0009904206 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootQ.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.000000029802322 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.000000029802322 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootQ.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.000000029802322 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.000000029802322 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootQ.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.9999995 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.9999995 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RootQ.w + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.09074765 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.09074765 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootT.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.99597967 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.99597967 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootT.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.032569747 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.032569747 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootT.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootQ.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.4995045 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.4995045 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootQ.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootQ.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.49950463 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.49950463 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftFootQ.w + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.08610656 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.08610656 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootT.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.99597967 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.99597967 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootT.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.03256977 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.03256977 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootT.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootQ.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.49950442 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.49950442 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootQ.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.50049496 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootQ.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.4995047 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.4995047 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightFootQ.w + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.6962602 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.6962602 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandT.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.39508566 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.39508566 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandT.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.029317556 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.029317556 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandT.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.0011194708 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.0011194708 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandQ.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.028612569 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.028612569 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandQ.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.99959004 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.99959004 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandQ.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.000031995765 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.000031995765 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHandQ.w + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6916188 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6916188 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandT.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.39508596 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.39508596 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandT.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.029317655 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.029317655 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandT.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.02861254 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.02861254 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandQ.x + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.0011195474 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.0011195474 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandQ.y + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.000032021475 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.000032021475 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandQ.z + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.99959004 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.99959004 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHandQ.w + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Spine Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Spine Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Spine Twist Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Chest Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Chest Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Chest Twist Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 1.6044449e-22 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 1.6044449e-22 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: UpperChest Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 2.0281193e-14 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 2.0281193e-14 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: UpperChest Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 3.1805545e-15 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 3.1805545e-15 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: UpperChest Twist Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.21768919 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.21768919 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Neck Nod Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.0000005364417 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.0000005364417 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Neck Tilt Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -2.5518072e-15 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -2.5518072e-15 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Neck Turn Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.1385466 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.1385466 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Head Nod Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.0000005064527 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.0000005064527 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Head Tilt Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.0000002003913 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.0000002003913 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Head Turn Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Eye Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Eye In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Eye Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Eye In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 1.0285543 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 1.0285543 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Jaw Close + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.0000021457988 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.0000021457988 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Jaw Left-Right + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.5288592 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.5288592 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Upper Leg Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.00000017935282 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.00000017935282 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Upper Leg In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.000000071362784 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.000000071362784 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Upper Leg Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.93421274 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.93421274 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Lower Leg Stretch + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00000023841858 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00000023841858 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Lower Leg Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.03387608 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.03387608 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Foot Up-Down + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00000055896726 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00000055896726 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Foot Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -1.4463487e-29 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -1.4463487e-29 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Toes Up-Down + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.5288592 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.5288592 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Upper Leg Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.000000049938695 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.000000049938695 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Upper Leg In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00000008376336 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00000008376336 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Upper Leg Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.93421274 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.93421274 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Lower Leg Stretch + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Lower Leg Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.03387639 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.03387639 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Foot Up-Down + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00000034893546 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00000034893546 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Foot Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Toes Up-Down + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.6577008 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.6577008 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Shoulder Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.026656672 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.026656672 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Shoulder Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.5008309 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.5008309 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Arm Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.2945701 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.2945701 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Arm Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00094974384 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00094974384 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Arm Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.89037263 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.89037263 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Forearm Stretch + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.0039196364 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.0039196364 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Forearm Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00038705475 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00038705475 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Hand Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.24678716 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.24678716 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Left Hand In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.65770036 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.65770036 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Shoulder Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.026655924 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.026655924 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Shoulder Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.5008307 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.5008307 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Arm Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.29456997 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.29456997 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Arm Front-Back + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00094974646 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00094974646 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Arm Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8903728 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8903728 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Forearm Stretch + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.0039196513 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.0039196513 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Forearm Twist In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.00038712102 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.00038712102 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Hand Down-Up + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.24678724 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.24678724 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: Right Hand In-Out + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.7149313 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.7149313 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Thumb.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.37668565 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.37668565 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Thumb.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.64628243 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.64628243 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Thumb.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.64628184 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.64628184 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Thumb.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Index.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.45739162 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.45739162 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Index.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Index.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Index.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Middle.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.61083114 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.61083114 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Middle.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Middle.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Middle.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.66797 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.66797 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Ring.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.6108282 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.6108282 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Ring.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Ring.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Ring.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Little.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.45739284 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.45739284 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Little.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Little.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116842 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: LeftHand.Little.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.71493024 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.71493024 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Thumb.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.37669381 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.37669381 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Thumb.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6462818 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6462818 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Thumb.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.64628184 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.64628184 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Thumb.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Index.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.45739165 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.45739165 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Index.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Index.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Index.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Middle.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.6108283 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.6108283 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Middle.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Middle.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116838 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Middle.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Ring.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.61083126 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.61083126 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Ring.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Ring.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Ring.3 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.6679698 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Little.1 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: -0.45739275 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: -0.45739275 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Little.Spread + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116837 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116837 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Little.2 Stretched + path: + classID: 95 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 2 + time: 0 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + - serializedVersion: 2 + time: 0.033333335 + value: 0.8116841 + inSlope: 0 + outSlope: 0 + tangentMode: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: RightHand.Little.3 Stretched + path: + classID: 95 + script: {fileID: 0} + m_EulerEditorCurves: [] + m_HasGenericRootTransform: 0 + m_HasMotionFloatCurves: 0 + m_GenerateMotionCurves: 0 + m_Events: [] diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/HumanoidDefault.anim.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/HumanoidDefault.anim.meta new file mode 100644 index 0000000000000000000000000000000000000000..0b38f70c2b93151f675382190183df518d02d0e6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/HumanoidDefault.anim.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: c91389c39d842cc4190ea8be0836798a +timeCreated: 1500990629 +licenseType: Pro +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 7400000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/Timeline_DarkSkin.txt b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/Timeline_DarkSkin.txt new file mode 100644 index 0000000000000000000000000000000000000000..14d0e57eae24524f6dffbd5b3b57f17e1aad94b6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/Timeline_DarkSkin.txt @@ -0,0 +1,52 @@ +colorPlayhead,RGBA(1.000, 1.000, 1.000, 1.000) +colorSelection,RGBA(0.239, 0.369, 0.596, 1.000) +colorEndmarker,RGBA(0.239, 0.369, 0.596, 1.000) +colorGroup,RGBA(0.153, 0.216, 0.224, 1.000) +colorGroupTrackBackground,RGBA(0.080, 0.305, 0.328, 0.178) +colorAnimation,RGBA(0.141, 0.333, 0.537, 1.000) +colorAnimationRecorded,RGBA(0.248, 0.463, 0.691, 1.000) +colorAudio,RGBA(1.000, 0.635, 0.000, 1.000) +colorAudioWaveform,RGBA(0.129, 0.164, 0.254, 1.000) +colorActivation,RGBA(0.000, 0.597, 0.128, 1.000) +colorDropTarget,RGBA(0.514, 0.627, 0.827, 1.000) +colorClipFont,RGBA(0.569, 0.580, 0.588, 1.000) +colorInvalidClipOverlay,RGBA(1.000, 0.000, 0.000, 0.502) +colorTrackBackground,RGBA(0.216, 0.216, 0.216, 0.628) +colorTrackHeaderBackground,RGBA(0.255, 0.255, 0.255, 1.000) +colorTrackDarken,RGBA(0.059, 0.059, 0.059, 0.672) +colorTrackBackgroundRecording,RGBA(0.622, 0.085, 0.085, 0.347) +colorInfiniteTrackBackgroundRecording,RGBA(0.391, 0.000, 0.000, 0.721) +colorTrackBackgroundSelected,RGBA(0.260, 0.339, 0.477, 0.516) +colorTrackFont,RGBA(0.718, 0.718, 0.718, 1.000) +colorClipUnion,RGBA(0.229, 0.280, 0.316, 0.709) +colorTopOutline3,RGBA(0.274, 0.274, 0.274, 1.000) +colorDurationLine,RGBA(0.153, 0.231, 0.376, 0.709) +colorRange,RGBA(0.733, 0.733, 0.733, 0.166) +colorSequenceBackground,RGBA(0.161, 0.161, 0.161, 1.000) +colorTooltipBackground,RGBA(0.114, 0.125, 0.129, 1.000) +colorInfiniteClipLine,RGBA(0.322, 0.322, 0.322, 1.000) +colorDefaultTrackDrawer,RGBA(0.855, 0.863, 0.871, 1.000) +colorDuration,RGBA(0.660, 0.660, 0.660, 1.000) +colorRecordingClipOutline,RGBA(1.000, 0.000, 0.000, 0.900) +colorAnimEditorBinding,RGBA(0.212, 0.212, 0.212, 1.000) +colorTimelineBackground,RGBA(0.216, 0.216, 0.216, 1.000) +colorLockTextBG,RGBA(0.601, 0.601, 0.601, 0.709) +colorInlineCurveVerticalLines,RGBA(1.000, 1.000, 1.000, 0.200) +colorInlineCurveOutOfRangeOverlay,RGBA(0.000, 0.000, 0.000, 0.500) +colorInlineCurvesBackground,RGBA(0.000, 0.000, 0.000, 0.000) +markerDrawerBackgroundColor,RGBA(0.180, 0.180, 0.180, 1.000) +markerHeaderDrawerBackgroundColor,RGBA(0.190, 0.190, 0.190, 1.000) +colorControl,RGBA(0.231, 0.635, 0.584, 1.000) +colorSubSequenceBackground,RGBA(0.218, 0.218, 0.218, 1.000) +colorTrackSubSequenceBackground,RGBA(0.153, 0.180, 0.180, 0.792) +colorTrackSubSequenceBackgroundSelected,RGBA(0.056, 0.189, 0.189, 1.000) +colorSubSequenceOverlay,RGBA(0.009, 0.080, 0.080, 0.286) +colorSubSequenceDurationLine,RGBA(0.000, 1.000, 0.880, 0.460) +clipBckg,RGBA(0.251, 0.267, 0.290, 1.000) +clipSelectedBckg,RGBA(0.408, 0.427, 0.478, 1.000) +clipBorderColor,RGBA(0.196, 0.196, 0.196, 1.000) +clipEaseBckgColor,RGBA(0.153, 0.153, 0.153, 1.000) +clipBlendIn,RGBA(0.286, 0.306, 0.329, 1.000) +clipBlendInSelected,RGBA(0.408, 0.427, 0.478, 1.000) +clipBlendOut,RGBA(0.286, 0.306, 0.329, 1.000) +clipBlendOutSelected,RGBA(0.408, 0.427, 0.478, 1.000) diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/Timeline_DarkSkin.txt.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/Timeline_DarkSkin.txt.meta new file mode 100644 index 0000000000000000000000000000000000000000..33aa8d2b69239dbac2b8ad2ea0c4a4b7f07773bc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/Timeline_DarkSkin.txt.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 54905d77593e9eb44a7c25d704bb4163 +timeCreated: 1471357208 +licenseType: Pro +TextScriptImporter: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/Timeline_LightSkin.txt b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/Timeline_LightSkin.txt new file mode 100644 index 0000000000000000000000000000000000000000..5495a19ffd54fb39b818d0e814c6a61975afcf32 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/Timeline_LightSkin.txt @@ -0,0 +1,52 @@ +colorPlayhead,RGBA(1.000, 1.000, 1.000, 1.000) +colorSelection,RGBA(0.290, 0.494, 0.878, 1.000) +colorEndmarker,RGBA(0.368, 0.599, 1.000, 1.000) +colorGroup,RGBA(0.518, 0.569, 0.576, 1.000) +colorGroupTrackBackground,RGBA(0.023, 0.235, 0.258, 0.157) +colorAnimation,RGBA(0.090, 0.388, 0.627, 1.000) +colorAnimationRecorded,RGBA(0.084, 0.450, 0.588, 1.000) +colorAudio,RGBA(1.000, 0.678, 0.000, 1.000) +colorAudioWaveform,RGBA(0.333, 0.388, 0.466, 1.000) +colorActivation,RGBA(0.000, 0.684, 0.148, 1.000) +colorDropTarget,RGBA(0.667, 0.788, 0.918, 1.000) +colorClipFont,RGBA(0.000, 0.000, 0.000, 0.804) +colorInvalidClipOverlay,RGBA(0.981, 0.000, 0.000, 0.502) +colorTrackBackground,RGBA(0.550, 0.550, 0.550, 0.561) +colorTrackHeaderBackground,RGBA(0.824, 0.824, 0.824, 1.000) +colorTrackDarken,RGBA(0.290, 0.290, 0.290, 0.591) +colorTrackBackgroundRecording,RGBA(0.422, 0.000, 0.000, 0.529) +colorInfiniteTrackBackgroundRecording,RGBA(0.410, 0.000, 0.000, 0.941) +colorTrackBackgroundSelected,RGBA(0.274, 0.466, 0.828, 0.459) +colorTrackFont,RGBA(0.000, 0.000, 0.000, 1.000) +colorClipUnion,RGBA(0.702, 0.741, 0.772, 0.472) +colorTopOutline3,RGBA(0.274, 0.274, 0.274, 1.000) +colorDurationLine,RGBA(0.467, 0.635, 0.925, 0.697) +colorRange,RGBA(1.000, 1.000, 1.000, 0.172) +colorSequenceBackground,RGBA(0.665, 0.665, 0.665, 1.000) +colorTooltipBackground,RGBA(0.266, 0.266, 0.266, 1.000) +colorInfiniteClipLine,RGBA(0.804, 0.804, 0.804, 1.000) +colorDefaultTrackDrawer,RGBA(0.855, 0.863, 0.871, 1.000) +colorDuration,RGBA(0.660, 0.660, 0.660, 1.000) +colorRecordingClipOutline,RGBA(1.000, 0.083, 0.083, 0.900) +colorAnimEditorBinding,RGBA(0.815, 0.815, 0.815, 1.000) +colorTimelineBackground,RGBA(0.855, 0.855, 0.855, 1.000) +colorLockTextBG,RGBA(0.341, 0.341, 0.341, 0.866) +colorInlineCurveVerticalLines,RGBA(1.000, 1.000, 1.000, 0.200) +colorInlineCurveOutOfRangeOverlay,RGBA(0.915, 0.915, 0.915, 0.569) +colorInlineCurvesBackground,RGBA(0.245, 0.245, 0.245, 0.471) +markerDrawerBackgroundColor,RGBA(0.517, 0.517, 0.517, 1.000) +markerHeaderDrawerBackgroundColor,RGBA(0.762, 0.762, 0.762, 1.000) +colorControl,RGBA(0.192, 0.693, 0.629, 1.000) +colorSubSequenceBackground,RGBA(0.695, 0.695, 0.695, 1.000) +colorTrackSubSequenceBackground,RGBA(0.280, 0.405, 0.389, 0.329) +colorTrackSubSequenceBackgroundSelected,RGBA(0.073, 0.252, 0.252, 1.000) +colorSubSequenceOverlay,RGBA(0.053, 0.118, 0.118, 0.300) +colorSubSequenceDurationLine,RGBA(0.200, 0.723, 0.654, 1.000) +clipBckg,RGBA(0.534, 0.551, 0.580, 1.000) +clipSelectedBckg,RGBA(0.690, 0.714, 0.753, 1.000) +clipBorderColor,RGBA(0.459, 0.476, 0.500, 1.000) +clipEaseBckgColor,RGBA(0.651, 0.651, 0.651, 1.000) +clipBlendIn,RGBA(0.533, 0.553, 0.580, 1.000) +clipBlendInSelected,RGBA(0.690, 0.714, 0.753, 1.000) +clipBlendOut,RGBA(0.533, 0.553, 0.580, 1.000) +clipBlendOutSelected,RGBA(0.690, 0.714, 0.753, 1.000) diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/Timeline_LightSkin.txt.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/Timeline_LightSkin.txt.meta new file mode 100644 index 0000000000000000000000000000000000000000..b1927d6d2a4ee87f4c79b300e4b0da96cfbc5eb4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/StyleSheets/res/Timeline_LightSkin.txt.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 3235ecefad2a6a645aa0222aca200aeb +timeCreated: 1471352677 +licenseType: Pro +TextScriptImporter: + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/ApplyDefaultUndoAttribute.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/ApplyDefaultUndoAttribute.cs new file mode 100644 index 0000000000000000000000000000000000000000..c7e00a186ba2c477477691c0b278742561f1540b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/ApplyDefaultUndoAttribute.cs @@ -0,0 +1,41 @@ +using System; + +namespace UnityEditor.Timeline.Actions +{ + /// + /// Use this attribute on action classes (, + /// , + /// and + /// ) + /// to have the default undo behaviour applied. + /// + /// By default, applying this attribute will record all objects passed to the Execute method with the Undo system, + /// using the name of Action it is applied to. + /// + /// + /// Simple track Action example (with context menu and shortcut support). + /// + /// + /// + /// + /// + /// + /// + [AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)] + public class ApplyDefaultUndoAttribute : Attribute + { + /// + /// The title of the action to appear in the undo history. If not specified, the name is taken from the DisplayName attribute, + /// or derived from the name of the class this attribute is applied to. + /// + public string UndoTitle; + + /// Use this attribute on action classes to have the default undo behaviour applied. + /// + /// The title of the action to appear in the undo history. + public ApplyDefaultUndoAttribute(string undoTitle = null) + { + UndoTitle = undoTitle; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/ApplyDefaultUndoAttribute.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/ApplyDefaultUndoAttribute.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..822503f87e55a78a73de4021c760c27237ceffe9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/ApplyDefaultUndoAttribute.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: b46a1ab31b3043b88cc57df2167383ac +timeCreated: 1590517869 \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/UndoExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/UndoExtensions.cs new file mode 100644 index 0000000000000000000000000000000000000000..f0975cef414e4d077632d577711f27442f3ebb14 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/UndoExtensions.cs @@ -0,0 +1,160 @@ +using System.Collections.Generic; +using UnityEditor.Timeline.Actions; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + /// + /// Use this class to record the state of a timeline or its components prior to modification. + /// + /// + /// These methods do not need to be used when adding or deleting tracks, clips or markers. + /// Methods in the UnityEngine.Timeline namespace, such as + /// or will apply the appropriate + /// Undo calls when called in Editor. + /// + public static class UndoExtensions + { + /// + /// Records all items contained in an action context. Use this method to record all objects + /// inside the context. + /// + /// The action context to record into the Undo system. + /// The title of the action to appear in the undo history (i.e. visible in the undo menu). + public static void RegisterContext(ActionContext context, string undoTitle) + { + using (var undo = new UndoScope(undoTitle)) + { + undo.Add(context.tracks); + undo.Add(context.clips, true); + undo.Add(context.markers); + } + } + + /// + /// Records any changes done on the timeline after being called. This only applies + /// to the timeline asset properties itself, and not any of the tracks or clips on the timeline + /// + /// The timeline asset being modified. + /// The title of the action to appear in the undo history (i.e. visible in the undo menu). + public static void RegisterTimeline(TimelineAsset asset, string undoTitle) + { + using (var undo = new UndoScope(undoTitle)) + undo.AddObject(asset); + } + + /// + /// Records any changes done on the timeline after being called, including any changes + /// to any clips, tracks and markers that occur on the timeline. + /// + /// The timeline asset being modified. + /// The title of the action to appear in the undo history (i.e. visible in the undo menu). + public static void RegisterCompleteTimeline(TimelineAsset asset, string undoTitle) + { + if (asset == null) + return; + + using (var undo = new UndoScope(undoTitle)) + { + undo.AddObject(asset); + undo.Add(asset.flattenedTracks); + foreach (var t in asset.flattenedTracks) + { + undo.Add(t.GetClips(), true); + undo.Add(t.GetMarkers()); + } + } + } + + /// + /// Records any changes done on the track after being called, including any changes + /// to clips on the track, but not on markers or PlayableAssets attached to the clips. + /// + /// The timeline track being modified. + /// The title of the action to appear in the undo history (i.e. visible in the undo menu). + public static void RegisterTrack(TrackAsset asset, string undoTitle) + { + using (var undo = new UndoScope(undoTitle)) + undo.AddObject(asset); + } + + /// + /// Records any changes done on the tracks after being called, including any changes + /// to clips on the tracks, but not on markers or PlayableAssets attached to the clips. + /// + /// The timeline track being modified. + /// The title of the action to appear in the undo history (i.e. visible in the undo menu). + public static void RegisterTracks(IEnumerable tracks, string undoTitle) + { + using (var undo = new UndoScope(undoTitle)) + undo.Add(tracks); + } + + /// + /// Records any changes done on the clip after being called. + /// + /// The timeline clip being modified. + /// The title of the action to appear in the undo history (i.e. visible in the undo menu). + /// Set this value to true to also record changes on the attached playable asset. + public static void RegisterClip(TimelineClip clip, string undoTitle, bool includePlayableAsset = true) + { + using (var undo = new UndoScope(undoTitle)) + { + undo.AddClip(clip, includePlayableAsset); + } + } + + /// + /// Records any changes done on the PlayableAsset after being called. + /// + /// The timeline track being modified. + /// The title of the action to appear in the undo history (i.e. visible in the undo menu). + public static void RegisterPlayableAsset(PlayableAsset asset, string undoTitle) + { + using (var undo = new UndoScope(undoTitle)) + undo.AddObject(asset); + } + + /// + /// Records any changes done on the clips after being called. + /// + /// The timeline clips being modified. + /// The title of the action to appear in the undo history (i.e. visible in the undo menu). + /// Set this value to true to also record changes on the attached playable assets. + public static void RegisterClips(IEnumerable clips, string name, bool includePlayableAssets = true) + { + using (var undo = new UndoScope(name)) + undo.Add(clips, includePlayableAssets); + } + + /// + /// Records any changes done on the Timeline Marker after being called. + /// + /// The timeline clip being modified. + /// The title of the action to appear in the undo history (i.e. visible in the undo menu). + public static void RegisterMarker(IMarker marker, string undoTitle) + { + using (var undo = new UndoScope(undoTitle)) + { + if (marker is Object o) + undo.AddObject(o); + else if (marker != null) + undo.AddObject(marker.parent); + } + } + + /// + /// Records any changes done on the Timeline Markers after being called. + /// + /// The timeline clip being modified. + /// The title of the action to appear in the undo history (i.e. visible in the undo menu). + public static void RegisterMarkers(IEnumerable markers, string undoTitle) + { + using (var undo = new UndoScope(undoTitle)) + undo.Add(markers); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/UndoExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/UndoExtensions.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..ee91e287838e81bd5fcd0ea63ff90ebf99621da7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/UndoExtensions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3484c53050e20474bb37d3808245721a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/UndoScope.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/UndoScope.cs new file mode 100644 index 0000000000000000000000000000000000000000..7085ac7de2fc36a0b9c7de0a4d0ba0e0b3f4b16b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/UndoScope.cs @@ -0,0 +1,85 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine.Timeline; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + /// + /// Disposable scope object used to collect multiple items for Undo. + /// Automatically filters out duplicates + /// + struct UndoScope : IDisposable + { + private static readonly HashSet s_ObjectsToUndo = new HashSet(); + private string m_Name; + + public UndoScope(string name) + { + m_Name = name; + } + + public void Dispose() + { + ApplyUndo(m_Name); + } + + public void AddObject(UnityEngine.Object asset) + { + if (asset != null) + s_ObjectsToUndo.Add(asset); + } + + public void AddClip(TimelineClip clip, bool includeAsset) + { + if (clip != null && clip.parentTrack != null) + s_ObjectsToUndo.Add(clip.parentTrack); + if (includeAsset && clip != null && clip.asset != null) + s_ObjectsToUndo.Add(clip.asset); + } + + public void Add(IEnumerable tracks) + { + if (tracks == null) + return; + + foreach (var track in tracks) + AddObject(track); + } + + public void Add(IEnumerable clips, bool includeAssets) + { + if (clips == null) + return; + + foreach (var clip in clips) + { + AddClip(clip, includeAssets); + } + } + + public void Add(IEnumerable markers) + { + if (markers == null) + return; + + foreach (var marker in markers) + { + if (marker is Object o) + AddObject(o); + else if (marker != null) + AddObject(marker.parent); + } + } + + private static void ApplyUndo(string name) + { + if (s_ObjectsToUndo.Count == 1) + TimelineUndo.PushUndo(s_ObjectsToUndo.First(), name); + else if (s_ObjectsToUndo.Count > 1) + TimelineUndo.PushUndo(s_ObjectsToUndo.ToArray(), name); + s_ObjectsToUndo.Clear(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/UndoScope.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/UndoScope.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e3a5d060920de780adc2c7267364523649a9e902 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Undo/UndoScope.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: ef85e74dfd3749279eff9e7fbfbaf3f8 +timeCreated: 1590436732 \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedParameterCache.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedParameterCache.cs new file mode 100644 index 0000000000000000000000000000000000000000..d5f091f5683b93e13803fb13e1be8df4e10cbde0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedParameterCache.cs @@ -0,0 +1,91 @@ +using System; +using System.Collections.Generic; +using System.Reflection; + +namespace UnityEditor.Timeline +{ + static class AnimatedParameterCache + { + static readonly Dictionary k_ScriptPlayableFieldsCache = new Dictionary(); + static readonly Dictionary k_PropertyFieldInfoCache = new Dictionary(); + static readonly Dictionary k_PropertyIsAnimatableCache = new Dictionary(); + static readonly Dictionary k_BindingNameCache = new Dictionary(); + + public static bool TryGetScriptPlayableFields(Type type, out FieldInfo[] scriptPlayableFields) + { + return k_ScriptPlayableFieldsCache.TryGetValue(type, out scriptPlayableFields); + } + + public static void SetScriptPlayableFields(Type type, FieldInfo[] scriptPlayableFields) + { + k_ScriptPlayableFieldsCache[type] = scriptPlayableFields; + } + + public static bool TryGetFieldInfoForProperty(SerializedProperty property, out FieldInfo fieldInfo) + { + return k_PropertyFieldInfoCache.TryGetValue(new PropertyKey(property), out fieldInfo); + } + + public static void SetFieldInfoForProperty(SerializedProperty property, FieldInfo fieldInfo) + { + k_PropertyFieldInfoCache[new PropertyKey(property)] = fieldInfo; + } + + public static bool TryGetIsPropertyAnimatable(SerializedProperty property, out bool isAnimatable) + { + return k_PropertyIsAnimatableCache.TryGetValue(new PropertyKey(property), out isAnimatable); + } + + public static void SetIsPropertyAnimatable(SerializedProperty property, bool isAnimatable) + { + k_PropertyIsAnimatableCache[new PropertyKey(property)] = isAnimatable; + } + + public static bool TryGetBindingName(Type type, string path, out string bindingName) + { + return k_BindingNameCache.TryGetValue(new PropertyKey(type, path), out bindingName); + } + + public static void SetBindingName(Type type, string path, string bindingName) + { + k_BindingNameCache[new PropertyKey(type, path)] = bindingName; + } + } + + struct PropertyKey : IEquatable + { + readonly Type m_Type; + readonly string m_Path; + + public PropertyKey(SerializedProperty property) + { + m_Type = property.serializedObject.targetObject.GetType(); + m_Path = property.propertyPath; + } + + public PropertyKey(Type type, string path) + { + m_Type = type; + m_Path = path; + } + + public bool Equals(PropertyKey other) + { + return m_Type == other.m_Type && string.Equals(m_Path, other.m_Path); + } + + public override bool Equals(object obj) + { + if (ReferenceEquals(null, obj)) return false; + return obj is PropertyKey && Equals((PropertyKey)obj); + } + + public override int GetHashCode() + { + unchecked + { + return ((m_Type != null ? m_Type.GetHashCode() : 0) * 397) ^ (m_Path != null ? m_Path.GetHashCode() : 0); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedParameterCache.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedParameterCache.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..19831f1922a8336a90e09111e16ac1520b166507 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedParameterCache.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1fe0f539450e54dbc85bfb2fa6b466fb +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedParameterUtility.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedParameterUtility.cs new file mode 100644 index 0000000000000000000000000000000000000000..1919cad4460c30b393bd6d98bf425063c8e455bd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedParameterUtility.cs @@ -0,0 +1,358 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; +using UnityObject = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + static class AnimatedParameterUtility + { + static readonly Type k_DefaultAnimationType = typeof(TimelineAsset); + static SerializedObject s_CachedObject; + + public static ICurvesOwner ToCurvesOwner(IPlayableAsset playableAsset, TimelineAsset timeline) + { + if (playableAsset == null) + return null; + + var curvesOwner = playableAsset as ICurvesOwner; + if (curvesOwner == null) + { + // If the asset is not directly an ICurvesOwner, it might be the asset for a TimelineClip + curvesOwner = TimelineRecording.FindClipWithAsset(timeline, playableAsset); + } + + return curvesOwner; + } + + public static bool TryGetSerializedPlayableAsset(UnityObject asset, out SerializedObject serializedObject) + { + serializedObject = null; + if (asset == null || Attribute.IsDefined(asset.GetType(), typeof(NotKeyableAttribute)) || !HasScriptPlayable(asset)) + return false; + + serializedObject = GetSerializedPlayableAsset(asset); + return serializedObject != null; + } + + public static SerializedObject GetSerializedPlayableAsset(UnityObject asset) + { + if (!(asset is IPlayableAsset)) + return null; + + var scriptObject = asset as ScriptableObject; + if (scriptObject == null) + return null; + + if (s_CachedObject == null || s_CachedObject.targetObject != asset) + { + s_CachedObject = new SerializedObject(scriptObject); + } + + return s_CachedObject; + } + + public static void UpdateSerializedPlayableAsset(UnityObject asset) + { + var so = GetSerializedPlayableAsset(asset); + if (so != null) + so.UpdateIfRequiredOrScript(); + } + + public static bool HasScriptPlayable(UnityObject asset) + { + if (asset == null) + return false; + + var scriptPlayable = asset as IPlayableBehaviour; + return scriptPlayable != null || GetScriptPlayableFields(asset as IPlayableAsset).Any(); + } + + public static FieldInfo[] GetScriptPlayableFields(IPlayableAsset asset) + { + if (asset == null) + return new FieldInfo[0]; + + FieldInfo[] scriptPlayableFields; + if (!AnimatedParameterCache.TryGetScriptPlayableFields(asset.GetType(), out scriptPlayableFields)) + { + scriptPlayableFields = GetScriptPlayableFields_Internal(asset); + AnimatedParameterCache.SetScriptPlayableFields(asset.GetType(), scriptPlayableFields); + } + + return scriptPlayableFields; + } + + static FieldInfo[] GetScriptPlayableFields_Internal(IPlayableAsset asset) + { + return asset.GetType() + .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) + .Where( + f => typeof(IPlayableBehaviour).IsAssignableFrom(f.FieldType) && // The field is an IPlayableBehaviour + (f.IsPublic || f.GetCustomAttributes(typeof(SerializeField), false).Any()) && // The field is either public or marked with [SerializeField] + !f.GetCustomAttributes(typeof(NotKeyableAttribute), false).Any() && // The field is not marked with [NotKeyable] + !f.GetCustomAttributes(typeof(HideInInspector), false).Any() && // The field is not marked with [HideInInspector] + !f.FieldType.GetCustomAttributes(typeof(NotKeyableAttribute), false).Any()) // The field is not of a type marked with [NotKeyable] + .ToArray(); + } + + public static bool HasAnyAnimatableParameters(UnityObject asset) + { + return GetAllAnimatableParameters(asset).Any(); + } + + public static IEnumerable GetAllAnimatableParameters(UnityObject asset) + { + SerializedObject serializedObject; + if (!TryGetSerializedPlayableAsset(asset, out serializedObject)) + yield break; + + var prop = serializedObject.GetIterator(); + + // We need to keep this variable because prop starts invalid + var outOfBounds = false; + while (!outOfBounds && prop.NextVisible(true)) + { + foreach (var property in SelectAnimatableProperty(prop)) + yield return property; + + // We can become out of bounds by calling SelectAnimatableProperty, if the last iterated property is a color. + outOfBounds = !prop.isValid; + } + } + + static IEnumerable SelectAnimatableProperty(SerializedProperty prop) + { + // We're only interested by animatable leaf parameters + if (!prop.hasChildren && IsParameterAnimatable(prop)) + yield return prop.Copy(); + + // Color type is not considered "visible" when iterating + if (prop.propertyType == SerializedPropertyType.Color) + { + var end = prop.GetEndProperty(); + + // For some reasons, if the last 2+ serialized properties are of type Color, prop becomes invalid and + // Next() throws an exception. This is not the case when only the last serialized property is a Color. + while (!SerializedProperty.EqualContents(prop, end) && prop.isValid && prop.Next(true)) + { + foreach (var property in SelectAnimatableProperty(prop)) + yield return property; + } + } + } + + public static bool IsParameterAnimatable(UnityObject asset, string parameterName) + { + SerializedObject serializedObject; + if (!TryGetSerializedPlayableAsset(asset, out serializedObject)) + return false; + + var prop = serializedObject.FindProperty(parameterName); + return IsParameterAnimatable(prop); + } + + public static bool IsParameterAnimatable(SerializedProperty property) + { + if (property == null) + return false; + + bool isAnimatable; + if (!AnimatedParameterCache.TryGetIsPropertyAnimatable(property, out isAnimatable)) + { + isAnimatable = IsParameterAnimatable_Internal(property); + AnimatedParameterCache.SetIsPropertyAnimatable(property, isAnimatable); + } + + return isAnimatable; + } + + static bool IsParameterAnimatable_Internal(SerializedProperty property) + { + if (property == null) + return false; + + var asset = property.serializedObject.targetObject; + + // Currently not supported + if (asset is AnimationTrack) + return false; + + if (IsParameterKeyable(property)) + return asset is IPlayableBehaviour || IsParameterAtPathAnimatable(asset, property.propertyPath); + + return false; + } + + static bool IsParameterKeyable(SerializedProperty property) + { + return IsTypeAnimatable(property.propertyType) && IsKeyableInHierarchy(property); + } + + static bool IsKeyableInHierarchy(SerializedProperty property) + { + const BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance; + var pathSegments = property.propertyPath.Split('.'); + var type = property.serializedObject.targetObject.GetType(); + foreach (var segment in pathSegments) + { + if (type.GetCustomAttributes(typeof(NotKeyableAttribute), false).Any()) + { + return false; + } + + if (type.IsArray) + return false; + + var fieldInfo = type.GetField(segment, bindingFlags); + + if (fieldInfo == null || + fieldInfo.GetCustomAttributes(typeof(NotKeyableAttribute), false).Any() || + fieldInfo.GetCustomAttributes(typeof(HideInInspector), false).Any()) + { + return false; + } + + type = fieldInfo.FieldType; + + // only value types are supported + if (!type.IsValueType && !typeof(IPlayableBehaviour).IsAssignableFrom(type)) + return false; + } + + return true; + } + + static bool IsParameterAtPathAnimatable(UnityObject asset, string path) + { + if (asset == null) + return false; + + return GetScriptPlayableFields(asset as IPlayableAsset) + .Any( + f => path.StartsWith(f.Name, StringComparison.Ordinal) && + path.Length > f.Name.Length && + path[f.Name.Length] == '.'); + } + + public static bool IsTypeAnimatable(SerializedPropertyType type) + { + // Note: Integer is not currently supported by the animated property system + switch (type) + { + case SerializedPropertyType.Boolean: + case SerializedPropertyType.Float: + case SerializedPropertyType.Vector2: + case SerializedPropertyType.Vector3: + case SerializedPropertyType.Color: + case SerializedPropertyType.Quaternion: + case SerializedPropertyType.Vector4: + return true; + default: + return false; + } + } + + public static bool IsParameterAnimated(UnityObject asset, AnimationClip animationData, string parameterName) + { + if (asset == null || animationData == null) + return false; + + var binding = GetCurveBinding(asset, parameterName); + var bindings = AnimationClipCurveCache.Instance.GetCurveInfo(animationData).bindings; + return bindings.Any(x => BindingMatchesParameterName(x, binding.propertyName)); + } + + // Retrieve an animated parameter curve. parameter name is required to include the appropriate field for vectors + // e.g.: position + public static AnimationCurve GetAnimatedParameter(UnityObject asset, AnimationClip animationData, string parameterName) + { + if (!(asset is ScriptableObject) || animationData == null) + return null; + + var binding = GetCurveBinding(asset, parameterName); + return AnimationUtility.GetEditorCurve(animationData, binding); + } + + // get an animatable curve binding for this parameter + public static EditorCurveBinding GetCurveBinding(UnityObject asset, string parameterName) + { + var animationName = GetAnimatedParameterBindingName(asset, parameterName); + return EditorCurveBinding.FloatCurve(string.Empty, GetValidAnimationType(asset), animationName); + } + + public static string GetAnimatedParameterBindingName(UnityObject asset, string parameterName) + { + if (asset == null) + return parameterName; + + string bindingName; + if (!AnimatedParameterCache.TryGetBindingName(asset.GetType(), parameterName, out bindingName)) + { + bindingName = GetAnimatedParameterBindingName_Internal(asset, parameterName); + AnimatedParameterCache.SetBindingName(asset.GetType(), parameterName, bindingName); + } + + return bindingName; + } + + static string GetAnimatedParameterBindingName_Internal(UnityObject asset, string parameterName) + { + if (asset is IPlayableBehaviour) + return parameterName; + + // strip the IScript playable field name + var fields = GetScriptPlayableFields(asset as IPlayableAsset); + foreach (var f in fields) + { + if (parameterName.StartsWith(f.Name, StringComparison.Ordinal)) + { + if (parameterName.Length > f.Name.Length && parameterName[f.Name.Length] == '.') + return parameterName.Substring(f.Name.Length + 1); + } + } + + return parameterName; + } + + public static bool BindingMatchesParameterName(EditorCurveBinding binding, string parameterName) + { + if (binding.propertyName == parameterName) + return true; + + var indexOfDot = binding.propertyName.LastIndexOf('.'); + return indexOfDot > 0 && parameterName.Length == indexOfDot && + binding.propertyName.StartsWith(parameterName, StringComparison.Ordinal); + } + + // the animated type must be a non-abstract instantiable object. + public static Type GetValidAnimationType(UnityObject asset) + { + return asset != null ? asset.GetType() : k_DefaultAnimationType; + } + + public static FieldInfo GetFieldInfoForProperty(SerializedProperty property) + { + FieldInfo fieldInfo; + + if (!AnimatedParameterCache.TryGetFieldInfoForProperty(property, out fieldInfo)) + { + Type _; + fieldInfo = ScriptAttributeUtility.GetFieldInfoFromProperty(property, out _); + AnimatedParameterCache.SetFieldInfoForProperty(property, fieldInfo); + } + + return fieldInfo; + } + + public static T GetAttributeForProperty(SerializedProperty property) where T : Attribute + { + var fieldInfo = GetFieldInfoForProperty(property); + return fieldInfo.GetCustomAttributes(typeof(T), false).FirstOrDefault() as T; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedParameterUtility.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedParameterUtility.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..695849fdaddbca3807c09d487a1e0a0f417d0d91 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedParameterUtility.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 84d86c98104d94063ad70bc591530f65 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedPropertyUtility.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedPropertyUtility.cs new file mode 100644 index 0000000000000000000000000000000000000000..9e4a969ce49bed63b3fc8532ecc97fcb97de20e5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedPropertyUtility.cs @@ -0,0 +1,73 @@ +using System; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + // Helper methods for animated properties + internal static class AnimatedPropertyUtility + { + public static bool IsMaterialProperty(string propertyName) + { + return propertyName.StartsWith("material."); + } + + /// + /// Given a propertyName (from an EditorCurveBinding), and the gameObject it refers to, + /// remaps the path to include the exposed name of the shader parameter + /// + /// The gameObject being referenced. + /// The propertyName to remap. + /// The remapped propertyName, or the original propertyName if it cannot be remapped + public static string RemapMaterialName(GameObject gameObject, string propertyName) + { + if (!IsMaterialProperty(propertyName) || gameObject == null) + return propertyName; + + var renderers = gameObject.GetComponents(); + if (renderers == null || renderers.Length == 0) + return propertyName; + + var propertySplits = propertyName.Split('.'); + if (propertySplits.Length <= 1) + return propertyName; + + // handles post fixes for texture properties + var exposedParameter = HandleTextureProperties(propertySplits[1], out var postFix); + foreach (var renderer in renderers) + { + foreach (var material in renderer.sharedMaterials) + { + if (material.shader == null) + continue; + + var index = material.shader.FindPropertyIndex(exposedParameter); + if (index >= 0) + { + propertySplits[1] = material.shader.GetPropertyDescription(index) + postFix; + return String.Join(".", propertySplits); + } + } + } + + return propertyName; + } + + private static string HandleTextureProperties(string exposedParameter, out string postFix) + { + postFix = String.Empty; + RemoveEnding(ref exposedParameter, ref postFix, "_ST"); + RemoveEnding(ref exposedParameter, ref postFix, "_TexelSize"); + RemoveEnding(ref exposedParameter, ref postFix, "_HDR"); + return exposedParameter; + } + + private static void RemoveEnding(ref string name, ref string postFix, string ending) + { + if (name.EndsWith(ending)) + { + name = name.Substring(0, name.Length - ending.Length); + postFix = ending; + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedPropertyUtility.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedPropertyUtility.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..84da3107363dc305ebeda3fa8d7cbeefff972425 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/AnimatedPropertyUtility.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: e22173cccd50433098692e06d6811255 +timeCreated: 1602163952 \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/BindingUtility.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/BindingUtility.cs new file mode 100644 index 0000000000000000000000000000000000000000..556581783c01f70e5275ccfc9bda167a42de3bbc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/BindingUtility.cs @@ -0,0 +1,58 @@ +using System; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + static class BindingUtility + { + public static Type GetRequiredBindingType(PlayableBinding binding) + { + return binding.outputTargetType; + } + + public static void Bind(PlayableDirector director, TrackAsset bindTo, Object objectToBind) + { + if (director == null || bindTo == null || TimelineWindow.instance == null) + return; + + TimelineWindow.instance.state.previewMode = false; // returns all objects to previous state + TimelineUndo.PushUndo(director, "PlayableDirector Binding"); + director.SetGenericBinding(bindTo, objectToBind); + TimelineWindow.instance.state.rebuildGraph = true; + } + + public static BindingAction GetBindingAction(Type requiredBindingType, Object objectToBind) + { + if (requiredBindingType == null || objectToBind == null) + return BindingAction.DoNotBind; + + // prevent drag and drop of prefab assets + if (PrefabUtility.IsPartOfPrefabAsset(objectToBind)) + return BindingAction.DoNotBind; + + if (requiredBindingType.IsInstanceOfType(objectToBind)) + return BindingAction.BindDirectly; + + var draggedGameObject = objectToBind as GameObject; + + if (!typeof(Component).IsAssignableFrom(requiredBindingType) || draggedGameObject == null) + return BindingAction.DoNotBind; + + if (draggedGameObject.GetComponent(requiredBindingType) == null) + return BindingAction.BindToMissingComponent; + + return BindingAction.BindToExistingComponent; + } + } + + enum BindingAction + { + DoNotBind, + BindDirectly, + BindToExistingComponent, + BindToMissingComponent + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/BindingUtility.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/BindingUtility.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..c528748db8d74a6f9a12ee749b0c7884b39ecbeb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/BindingUtility.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ef5fa6e2005defb4ab5142723827b58e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/BreadcrumbDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/BreadcrumbDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..98214d878be3f24ec5ed02aad8477523ec5b4eeb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/BreadcrumbDrawer.cs @@ -0,0 +1,224 @@ +using System; +using System.Collections.Generic; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + enum TitleMode + { + None, + DisabledComponent, + Prefab, + PrefabOutOfContext, + Asset, + GameObject + } + + struct BreadCrumbTitle + { + public string name; + public TitleMode mode; + } + + class BreadcrumbDrawer + { + static readonly GUIContent s_TextContent = new GUIContent(); + static readonly string k_DisabledComponentText = L10n.Tr("The PlayableDirector is disabled"); + static readonly string k_PrefabOutOfContext = L10n.Tr("Prefab Isolation not enabled. Click to Enable."); + + static readonly GUIStyle k_BreadCrumbLeft; + static readonly GUIStyle k_BreadCrumbMid; + static readonly GUIStyle k_BreadCrumbLeftBg; + static readonly GUIStyle k_BreadCrumbMidBg; + static readonly GUIStyle k_BreadCrumbMidSelected; + static readonly GUIStyle k_BreadCrumbMidBgSelected; + + static readonly Texture k_TimelineIcon; + + const string k_Elipsis = "…"; + + static BreadcrumbDrawer() + { + k_BreadCrumbLeft = "GUIEditor.BreadcrumbLeft"; + k_BreadCrumbMid = "GUIEditor.BreadcrumbMid"; + k_BreadCrumbLeftBg = "GUIEditor.BreadcrumbLeftBackground"; + k_BreadCrumbMidBg = "GUIEditor.BreadcrumbMidBackground"; + + k_BreadCrumbMidSelected = k_BreadCrumbMid; + k_BreadCrumbMidSelected.normal = k_BreadCrumbMidSelected.onNormal; + + k_BreadCrumbMidBgSelected = k_BreadCrumbMidBg; + k_BreadCrumbMidBgSelected.normal = k_BreadCrumbMidBgSelected.onNormal; + k_TimelineIcon = EditorGUIUtility.IconContent("TimelineAsset Icon").image; + } + + static string FitTextInArea(float areaWidth, string text, GUIStyle style) + { + var borderWidth = style.border.left + style.border.right; + var textWidth = style.CalcSize(EditorGUIUtility.TextContent(text)).x; + + if (borderWidth + textWidth < areaWidth) + return text; + + // Need to truncate the text to fit in the areaWidth + var textAreaWidth = areaWidth - borderWidth; + var pixByChar = textWidth / text.Length; + var charNeeded = (int)Mathf.Floor(textAreaWidth / pixByChar); + charNeeded -= k_Elipsis.Length; + + if (charNeeded <= 0) + return k_Elipsis; + + if (charNeeded <= text.Length) + return k_Elipsis + " " + text.Substring(text.Length - charNeeded); + + return k_Elipsis; + } + + public static void Draw(float breadcrumbAreaWidth, List labels, Action navigateToBreadcrumbIndex) + { + GUILayout.BeginHorizontal(); + { + var labelWidth = (int)(breadcrumbAreaWidth / labels.Count); + + for (var i = 0; i < labels.Count; i++) + { + var label = labels[i]; + + var style = i == 0 ? k_BreadCrumbLeft : k_BreadCrumbMid; + var backgroundStyle = i == 0 ? k_BreadCrumbLeftBg : k_BreadCrumbMidBg; + + if (i == labels.Count - 1) + { + if (i > 0) // Only tint last breadcrumb if we are dug-in + DrawBreadcrumbAsSelectedSubSequence(labelWidth, label, k_BreadCrumbMidSelected, k_BreadCrumbMidBgSelected); + else + DrawActiveBreadcrumb(labelWidth, label, style, backgroundStyle); + } + else + { + var previousContentColor = GUI.contentColor; + GUI.contentColor = new Color(previousContentColor.r, + previousContentColor.g, + previousContentColor.b, + previousContentColor.a * 0.6f); + var content = GetTextContent(labelWidth, label, style); + var rect = GetBreadcrumbLayoutRect(content, style); + + if (Event.current.type == EventType.Repaint) + backgroundStyle.Draw(rect, GUIContent.none, 0); + + if (GUI.Button(rect, content, style)) + navigateToBreadcrumbIndex.Invoke(i); + GUI.contentColor = previousContentColor; + } + } + } + GUILayout.EndHorizontal(); + } + + static GUIContent GetTextContent(int width, BreadCrumbTitle text, GUIStyle style) + { + s_TextContent.tooltip = string.Empty; + s_TextContent.image = null; + if (text.mode == TitleMode.DisabledComponent) + { + s_TextContent.tooltip = k_DisabledComponentText; + s_TextContent.image = EditorGUIUtility.GetHelpIcon(MessageType.Warning); + } + else if (text.mode == TitleMode.Prefab) + s_TextContent.image = PrefabUtility.GameObjectStyles.prefabIcon; + else if (text.mode == TitleMode.GameObject) + s_TextContent.image = PrefabUtility.GameObjectStyles.gameObjectIcon; + else if (text.mode == TitleMode.Asset) + s_TextContent.image = k_TimelineIcon; + else if (text.mode == TitleMode.PrefabOutOfContext) + { + s_TextContent.image = PrefabUtility.GameObjectStyles.prefabIcon; + if (!TimelineWindow.instance.locked) + s_TextContent.tooltip = k_PrefabOutOfContext; + } + + if (s_TextContent.image != null) + width = Math.Max(0, width - s_TextContent.image.width); + s_TextContent.text = FitTextInArea(width, text.name, style); + + return s_TextContent; + } + + static void DrawBreadcrumbAsSelectedSubSequence(int width, BreadCrumbTitle label, GUIStyle style, GUIStyle backgroundStyle) + { + var rect = DrawActiveBreadcrumb(width, label, style, backgroundStyle); + const float underlineThickness = 2.0f; + const float underlineVerticalOffset = 0.0f; + var underlineHorizontalOffset = backgroundStyle.border.right * 0.333f; + var underlineRect = Rect.MinMaxRect( + rect.xMin - underlineHorizontalOffset, + rect.yMax - underlineThickness - underlineVerticalOffset, + rect.xMax - underlineHorizontalOffset, + rect.yMax - underlineVerticalOffset); + + EditorGUI.DrawRect(underlineRect, DirectorStyles.Instance.customSkin.colorSubSequenceDurationLine); + } + + static Rect GetBreadcrumbLayoutRect(GUIContent content, GUIStyle style) + { + // the image makes the button far too big compared to non-image versions + var image = content.image; + content.image = null; + var size = style.CalcSizeWithConstraints(content, Vector2.zero); + content.image = image; + if (image != null) + size.x += size.y; // assumes square image, constrained by height + + return GUILayoutUtility.GetRect(content, style, GUILayout.MaxWidth(size.x)); + } + + static Rect DrawActiveBreadcrumb(int width, BreadCrumbTitle label, GUIStyle style, GUIStyle backgroundStyle) + { + var content = GetTextContent(width, label, style); + var rect = GetBreadcrumbLayoutRect(content, style); + + if (Event.current.type == EventType.Repaint) + { + backgroundStyle.Draw(rect, GUIContent.none, 0); + } + + if (GUI.Button(rect, content, style)) + { + UnityEngine.Object target = TimelineEditor.inspectedDirector; + if (target == null) + target = TimelineEditor.inspectedAsset; + if (target != null) + { + bool ping = true; + if (label.mode == TitleMode.PrefabOutOfContext) + { + var gameObject = PrefabUtility.GetRootGameObject(target); + if (gameObject != null) + { + target = gameObject; // ping the prefab root if it's locked. + if (!TimelineWindow.instance.locked) + { + var assetPath = AssetDatabase.GetAssetPath(gameObject); + if (!string.IsNullOrEmpty(assetPath)) + { + var stage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.OpenPrefab(assetPath); + if (stage != null) + ping = false; + } + } + } + } + + if (ping) + { + EditorGUIUtility.PingObject(target); + } + } + } + + return rect; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/BreadcrumbDrawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/BreadcrumbDrawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..b17803a5ed97dd5a8fb68bd55c6d2dbd4ede17f1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/BreadcrumbDrawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 526f285e8d4fb8140b4cdfeb9102d8cb +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ClipModifier.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ClipModifier.cs new file mode 100644 index 0000000000000000000000000000000000000000..07f95bddc68aeb490334050493a1e325d046e281 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ClipModifier.cs @@ -0,0 +1,397 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine.Timeline; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + static class ClipModifier + { + public static bool Delete(TimelineAsset timeline, TimelineClip clip) + { + return timeline.DeleteClip(clip); + } + + public static bool Tile(IEnumerable clips) + { + if (clips.Count() < 2) + return false; + + var clipsByTracks = clips.GroupBy(x => x.parentTrack) + .Select(track => new {track.Key, Items = track.OrderBy(c => c.start)}); + + foreach (var track in clipsByTracks) + { + UndoExtensions.RegisterTrack(track.Key, "Tile"); + } + + foreach (var track in clipsByTracks) + { + double newStart = track.Items.First().start; + foreach (var c in track.Items) + { + c.start = newStart; + newStart += c.duration; + } + } + + return true; + } + + public static bool TrimStart(IEnumerable clips, double trimTime) + { + var result = false; + + foreach (var clip in clips) + result |= TrimStart(clip, trimTime); + + return result; + } + + public static bool TrimStart(TimelineClip clip, double trimTime) + { + if (clip.asset == null) + return false; + + if (clip.start > trimTime) + return false; + + if (clip.end < trimTime) + return false; + + UndoExtensions.RegisterClip(clip, "Trim Clip Start"); + + // Note: We are NOT using edit modes in this case because we want the same result + // regardless of the selected EditMode: split at cursor and delete left part + SetStart(clip, trimTime, false); + clip.ConformEaseValues(); + + return true; + } + + public static bool TrimEnd(IEnumerable clips, double trimTime) + { + var result = false; + + foreach (var clip in clips) + result |= TrimEnd(clip, trimTime); + + return result; + } + + public static bool TrimEnd(TimelineClip clip, double trimTime) + { + if (clip.asset == null) + return false; + + if (clip.start > trimTime) + return false; + + if (clip.end < trimTime) + return false; + + UndoExtensions.RegisterClip(clip, "Trim Clip End"); + TrimClipWithEditMode(clip, TrimEdge.End, trimTime); + + return true; + } + + public static bool MatchDuration(IEnumerable clips) + { + double referenceDuration = clips.First().duration; + UndoExtensions.RegisterClips(clips, "Match Clip Duration"); + foreach (var clip in clips) + { + var newEnd = clip.start + referenceDuration; + TrimClipWithEditMode(clip, TrimEdge.End, newEnd); + } + + return true; + } + + public static bool Split(IEnumerable clips, double splitTime, PlayableDirector director) + { + var result = false; + + foreach (var clip in clips) + { + if (clip.start >= splitTime) + continue; + + if (clip.end <= splitTime) + continue; + + UndoExtensions.RegisterClip(clip, "Split Clip"); + + TimelineClip newClip = TimelineHelpers.Clone(clip, director, director, clip.start); + + clip.easeInDuration = 0; + newClip.easeOutDuration = 0; + + SetStart(clip, splitTime, false); + SetEnd(newClip, splitTime, false); + + // Sort produced by cloning clips on top of each other is unpredictable (it varies between mono runtimes) + clip.parentTrack.SortClips(); + + result = true; + } + + return result; + } + + public static void SetStart(TimelineClip clip, double time, bool affectTimeScale) + { + var supportsClipIn = clip.SupportsClipIn(); + var supportsPadding = TimelineUtility.IsRecordableAnimationClip(clip); + bool calculateTimeScale = (affectTimeScale && clip.SupportsSpeedMultiplier()); + + // 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 && !calculateTimeScale) + { + 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 (calculateTimeScale) + { + var f = clip.duration / duration; + clip.timeScale *= f; + } + + + if (supportsClipIn && !calculateTimeScale) + { + 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; + } + + public static void SetEnd(TimelineClip clip, double time, bool affectTimeScale) + { + var duration = Math.Max(time - clip.start, TimelineClip.kMinDuration); + + if (affectTimeScale && clip.SupportsSpeedMultiplier()) + { + var f = clip.duration / duration; + clip.timeScale *= f; + } + + clip.duration = duration; + } + + public static bool ResetEditing(IEnumerable clips) + { + var result = false; + + foreach (var clip in clips) + result = result || ResetEditing(clip); + + return result; + } + + public static bool ResetEditing(TimelineClip clip) + { + if (clip.asset == null) + return false; + + UndoExtensions.RegisterClip(clip, "Reset Clip Editing"); + + clip.clipIn = 0.0; + + if (clip.clipAssetDuration < double.MaxValue) + { + var duration = clip.clipAssetDuration / clip.timeScale; + TrimClipWithEditMode(clip, TrimEdge.End, clip.start + duration); + } + + return true; + } + + public static bool MatchContent(IEnumerable clips) + { + var result = false; + + foreach (var clip in clips) + result = result || MatchContent(clip); + + return result; + } + + public static bool MatchContent(TimelineClip clip) + { + if (clip.asset == null) + return false; + + UndoExtensions.RegisterClip(clip, "Match Clip Content"); + + var newStartCandidate = clip.start - clip.clipIn / clip.timeScale; + var newStart = newStartCandidate < 0.0 ? 0.0 : newStartCandidate; + + TrimClipWithEditMode(clip, TrimEdge.Start, newStart); + + // In case resetting the start was blocked by edit mode or timeline start, we do the best we can + clip.clipIn = (clip.start - newStartCandidate) * clip.timeScale; + if (clip.clipAssetDuration > 0 && TimelineHelpers.HasUsableAssetDuration(clip)) + { + var duration = TimelineHelpers.GetLoopDuration(clip); + var offset = (clip.clipIn / clip.timeScale) % duration; + TrimClipWithEditMode(clip, TrimEdge.End, clip.start - offset + duration); + } + + return true; + } + + public static void TrimClipWithEditMode(TimelineClip clip, TrimEdge edge, double time) + { + var clipItem = ItemsUtils.ToItem(clip); + EditMode.BeginTrim(clipItem, edge); + if (edge == TrimEdge.Start) + EditMode.TrimStart(clipItem, time, false); + else + EditMode.TrimEnd(clipItem, time, false); + EditMode.FinishTrim(); + } + + public static bool CompleteLastLoop(IEnumerable clips) + { + foreach (var clip in clips) + { + CompleteLastLoop(clip); + } + + return true; + } + + public static void CompleteLastLoop(TimelineClip clip) + { + FixLoops(clip, true); + } + + public static bool TrimLastLoop(IEnumerable clips) + { + foreach (var clip in clips) + { + TrimLastLoop(clip); + } + + return true; + } + + public static void TrimLastLoop(TimelineClip clip) + { + FixLoops(clip, false); + } + + static void FixLoops(TimelineClip clip, bool completeLastLoop) + { + if (!TimelineHelpers.HasUsableAssetDuration(clip)) + return; + + var loopDuration = TimelineHelpers.GetLoopDuration(clip); + var firstLoopDuration = loopDuration - clip.clipIn * (1.0 / clip.timeScale); + + // Making sure we don't trim to zero + if (!completeLastLoop && firstLoopDuration > clip.duration) + return; + + var numLoops = (clip.duration - firstLoopDuration) / loopDuration; + var numCompletedLoops = Math.Floor(numLoops); + + if (!(numCompletedLoops < numLoops)) + return; + + if (completeLastLoop) + numCompletedLoops += 1; + + var newEnd = clip.start + firstLoopDuration + loopDuration * numCompletedLoops; + + UndoExtensions.RegisterClip(clip, "Trim Clip Last Loop"); + + TrimClipWithEditMode(clip, TrimEdge.End, newEnd); + } + + public static bool DoubleSpeed(IEnumerable clips) + { + foreach (var clip in clips) + { + if (clip.SupportsSpeedMultiplier()) + { + UndoExtensions.RegisterClip(clip, "Double Clip Speed"); + clip.timeScale = clip.timeScale * 2.0f; + } + } + + return true; + } + + public static bool HalfSpeed(IEnumerable clips) + { + foreach (var clip in clips) + { + if (clip.SupportsSpeedMultiplier()) + { + UndoExtensions.RegisterClip(clip, "Half Clip Speed"); + clip.timeScale = clip.timeScale * 0.5f; + } + } + + return true; + } + + public static bool ResetSpeed(IEnumerable clips) + { + foreach (var clip in clips) + { + if (clip.timeScale != 1.0) + { + UndoExtensions.RegisterClip(clip, "Reset Clip Speed"); + clip.timeScale = 1.0; + } + } + + return true; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ClipModifier.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ClipModifier.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..3fa03b90185d96700e2a9fefbfb7a56f0a87df51 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ClipModifier.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b0eeee3cdfa56734abca5c1a4e7989ba +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Clipboard.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Clipboard.cs new file mode 100644 index 0000000000000000000000000000000000000000..063d66d2151e8f61915ffcd39090e3cd5bddf8f1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Clipboard.cs @@ -0,0 +1,144 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class Clipboard + { + class ExposedReferenceTable : IExposedPropertyTable + { + Dictionary m_ReferenceTable = new Dictionary(); + public void SetReferenceValue(PropertyName id, Object value) + { + m_ReferenceTable[id] = value; + } + + public Object GetReferenceValue(PropertyName id, out bool idValid) + { + Object reference; + idValid = m_ReferenceTable.TryGetValue(id, out reference); + return reference; + } + + public void ClearReferenceValue(PropertyName id) + { + m_ReferenceTable.Remove(id); + } + + public void Clear() + { + m_ReferenceTable.Clear(); + } + } + + public struct ClipboardTrackEntry + { + public TrackAsset item; + public TrackAsset parent; + public Object binding; + } + + static readonly int kListInitialSize = 10; + + readonly List m_ItemsData = new List(kListInitialSize); + readonly List m_trackData = new List(kListInitialSize); + TimelineAsset rootTimeline; + + public readonly IExposedPropertyTable exposedPropertyTable = new ExposedReferenceTable(); + + public Clipboard() + { + rootTimeline = CreateTimeline(); + + EditorApplication.playModeStateChanged += OnPlayModeChanged; + } + + public void CopyItems(IEnumerable items) + { + using (new TimelineUndo.DisableUndoGuard(true)) + { + var itemsByParent = items.ToLookup(i => i.parentTrack); + foreach (var itemsGroup in itemsByParent) + { + var parent = itemsGroup.Key; + var itemsList = new List(); + foreach (var item in itemsGroup) + { + if (item is ClipItem) + itemsList.Add(CopyItem((ClipItem)item)); + else if (item is MarkerItem) + itemsList.Add(CopyItem((MarkerItem)item)); + } + m_ItemsData.Add(new ItemsPerTrack(parent, itemsList)); + } + } + } + + ClipItem CopyItem(ClipItem clipItem) + { + var newClip = TimelineHelpers.Clone(clipItem.clip, TimelineWindow.instance.state.editSequence.director, exposedPropertyTable, rootTimeline); + return new ClipItem(newClip); + } + + static MarkerItem CopyItem(MarkerItem markerItem) + { + var markerObject = markerItem.marker as Object; + if (markerObject != null) + { + var newMarker = Object.Instantiate(markerObject); + newMarker.name = markerObject.name; + return new MarkerItem((IMarker)newMarker); + } + + return null; + } + + public void CopyTracks(IEnumerable tracks) + { + using (new TimelineUndo.DisableUndoGuard(true)) + { + foreach (var track in TrackExtensions.FilterTracks(tracks)) + { + var newTrack = track.Duplicate(TimelineEditor.inspectedDirector, TimelineEditor.clipboard.exposedPropertyTable, rootTimeline); + var bind = TimelineEditor.inspectedDirector != null ? TimelineEditor.inspectedDirector.GetGenericBinding(track) : null; + m_trackData.Add(new ClipboardTrackEntry {item = newTrack, parent = track.parent as TrackAsset, binding = bind}); + } + } + } + + public IEnumerable GetTracks() + { + return m_trackData; + } + + public IEnumerable GetCopiedItems() + { + return m_ItemsData; + } + + public void Clear() + { + m_ItemsData.Clear(); + m_trackData.Clear(); + rootTimeline = CreateTimeline(); + ((ExposedReferenceTable)exposedPropertyTable).Clear(); + } + + private void OnPlayModeChanged(PlayModeStateChange state) + { + if (state == PlayModeStateChange.EnteredEditMode || state == PlayModeStateChange.EnteredPlayMode) + Clear(); + } + + static TimelineAsset CreateTimeline() + { + var timeline = ScriptableObject.CreateInstance(); + timeline.hideFlags |= HideFlags.DontSave; + timeline.name = "Clipboard"; + + return timeline; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Clipboard.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Clipboard.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..af5870aa26361c4b1a917df3e6d769126e24e1dc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Clipboard.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b57629d89799e004182564256307b0cc +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ControlPlayableUtility.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ControlPlayableUtility.cs new file mode 100644 index 0000000000000000000000000000000000000000..d7023e49fb10f4f398c3840dc869d0351faab0ae --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ControlPlayableUtility.cs @@ -0,0 +1,62 @@ +using System.Collections.Generic; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class ControlPlayableUtility + { + public static bool DetectCycle( + ControlPlayableAsset asset, PlayableDirector director, HashSet set = null) + { + if (director == null || asset == null || !asset.updateDirector) + return false; + + if (set == null) + set = new HashSet(); + + if (set.Contains(director)) + return true; + + var gameObject = asset.sourceGameObject.Resolve(director); + if (gameObject == null) + return false; + + set.Add(director); + + foreach (var subDirector in asset.GetComponent(gameObject)) + { + foreach (var childAsset in GetPlayableAssets(subDirector)) + { + if (DetectCycle(childAsset, subDirector, set)) + return true; + } + } + + set.Remove(director); + + return false; + } + + public static IEnumerable GetPlayableAssets(PlayableDirector director) + { + var timeline = director != null ? (director.playableAsset as TimelineAsset) : null; + if (timeline != null) + { + foreach (var t in timeline.GetOutputTracks()) + { + var controlTrack = t as ControlTrack; + if (controlTrack != null) + { + foreach (var c in t.GetClips()) + { + var asset = c.asset as ControlPlayableAsset; + if (asset != null) + yield return asset; + } + } + } + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ControlPlayableUtility.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ControlPlayableUtility.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..ab502a141066940ab8c17ec839a990cf99382779 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ControlPlayableUtility.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e801faa3b0dd2478dbe801a2441b679e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/CustomTrackDrawerAttribute.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/CustomTrackDrawerAttribute.cs new file mode 100644 index 0000000000000000000000000000000000000000..b1a67aec2092272ed1bdcc2ed84d66504b177a02 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/CustomTrackDrawerAttribute.cs @@ -0,0 +1,44 @@ +using System; + +namespace UnityEditor.Timeline +{ + // Tells a custom [[TrackDrawer]] which [[TrackAsset]] it's a drawer for. + sealed class CustomTrackDrawerAttribute : Attribute + { + public Type assetType; + public CustomTrackDrawerAttribute(Type type) + { + assetType = type; + } + } + + /// + /// Attribute that specifies a class as an editor for an extended Timeline type. + /// + /// + /// Use this attribute on a class that extends ClipEditor, TrackEditor, or MarkerEditor to specify either the PlayableAsset, Marker, or TrackAsset derived classes for associated customization. + /// + /// + /// + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)] + public sealed class CustomTimelineEditorAttribute : Attribute + { + /// + /// The type that that this editor applies to. + /// + public Type classToEdit { get; private set; } + + /// + /// Constructor. + /// + /// The type that that this editor applies to. + /// Thrown if type is null + public CustomTimelineEditorAttribute(Type type) + { + if (type == null) + throw new System.ArgumentNullException(nameof(type)); + classToEdit = type; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/CustomTrackDrawerAttribute.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/CustomTrackDrawerAttribute.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1738611350bce60a005a502a4314dd51adacbec9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/CustomTrackDrawerAttribute.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e1e957d39ca70834f9212a1289b6a0d5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/DisplayNameHelper.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/DisplayNameHelper.cs new file mode 100644 index 0000000000000000000000000000000000000000..f228c4c2b31f550b2040cea24afcc9b63df22136 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/DisplayNameHelper.cs @@ -0,0 +1,33 @@ +using System.Text; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + static class DisplayNameHelper + { + static readonly string k_NoAssetDisplayName = L10n.Tr(""); + static readonly string k_ReadOnlyDisplayName = L10n.Tr("[Read Only]"); + static readonly StringBuilder k_StringBuilder = new StringBuilder(); + + public static string GetDisplayName(ISequenceState sequence) + { + string displayName = sequence.director != null ? GetDisplayName(sequence.director) : GetDisplayName(sequence.asset); + if (sequence.asset != null && sequence.isReadOnly) + displayName += " " + k_ReadOnlyDisplayName; + return displayName; + } + + public static string GetDisplayName(PlayableAsset asset) + { + return asset != null ? asset.name : k_NoAssetDisplayName; + } + + public static string GetDisplayName(PlayableDirector director) + { + k_StringBuilder.Length = 0; + k_StringBuilder.Append(GetDisplayName(director.playableAsset)); + k_StringBuilder.Append(" (").Append(director.name).Append(')'); + return k_StringBuilder.ToString(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/DisplayNameHelper.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/DisplayNameHelper.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..cb233c86d0adfc30e6d40c6412aa418d8f8aa019 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/DisplayNameHelper.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 7fc2147e42d71644aad0eaf9a3526249 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Graphics.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Graphics.cs new file mode 100644 index 0000000000000000000000000000000000000000..cc9addf59391b63b6e30280bb9f90e2466a20f1c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Graphics.cs @@ -0,0 +1,109 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + static class Graphics + { + public static void ShadowLabel(Rect rect, string text, GUIStyle style, Color textColor, Color shadowColor) + { + ShadowLabel(rect, GUIContent.Temp(text), style, textColor, shadowColor); + } + + public static void ShadowLabel(Rect rect, GUIContent content, GUIStyle style, Color textColor, Color shadowColor) + { + var shadowRect = rect; + shadowRect.xMin += 2.0f; + shadowRect.yMin += 2.0f; + style.normal.textColor = Color.black; + GUI.Label(shadowRect, content, style); + + style.normal.textColor = textColor; + GUI.Label(rect, content, style); + } + + public static void DrawLine(Vector3 p1, Vector3 p2, Color color) + { + var c = Handles.color; + Handles.color = color; + Handles.DrawLine(p1, p2); + Handles.color = c; + } + + public static void DrawPolygonAA(Color color, Vector3[] vertices) + { + var prevColor = Handles.color; + Handles.color = color; + Handles.DrawAAConvexPolygon(vertices); + Handles.color = prevColor; + } + + public static void DrawDottedLine(Vector3 p1, Vector3 p2, float segmentsLength, Color col) + { + HandleUtility.ApplyWireMaterial(); + + GL.Begin(GL.LINES); + GL.Color(col); + + var length = Vector3.Distance(p1, p2); // ignore z component + var count = Mathf.CeilToInt(length / segmentsLength); + for (var i = 0; i < count; i += 2) + { + GL.Vertex((Vector3.Lerp(p1, p2, i * segmentsLength / length))); + GL.Vertex((Vector3.Lerp(p1, p2, (i + 1) * segmentsLength / length))); + } + + GL.End(); + } + + public static void DrawLineAtTime(WindowState state, double time, Color color, bool dotted = false) + { + var t = state.TimeToPixel(time); + + var p0 = new Vector3(t, state.timeAreaRect.yMax); + var p1 = new Vector3(t, state.timeAreaRect.yMax + state.windowHeight - WindowConstants.sliderWidth); + + if (dotted) + DrawDottedLine(p0, p1, 4.0f, color); + else + DrawLine(p0, p1, color); + } + + public static void DrawTextureRepeated(Rect area, Texture texture) + { + if (texture == null || Event.current.type != EventType.Repaint) + return; + + GUI.BeginClip(area); + int w = Mathf.CeilToInt(area.width / texture.width); + int h = Mathf.CeilToInt(area.height / texture.height); + for (int x = 0; x < w; x++) + { + for (int y = 0; y < h; y++) + { + GUI.DrawTexture(new Rect(x * texture.width, y * texture.height, texture.width, texture.height), texture); + } + } + + GUI.EndClip(); + } + + public static void DrawShadow(Rect clientRect) + { + var rect = clientRect; + rect.height = WindowConstants.shadowUnderTimelineHeight; + GUI.Box(rect, GUIContent.none, DirectorStyles.Instance.bottomShadow); + } + + public static void DrawBackgroundRect(WindowState state, Rect rect, bool subSequenceMode = false) + { + Color c = subSequenceMode ? DirectorStyles.Instance.customSkin.colorSubSequenceBackground : DirectorStyles.Instance.customSkin.colorSequenceBackground; + EditorGUI.DrawRect(rect, c); + if (state.IsEditingAPrefabAsset()) + { + c = SceneView.kSceneViewPrefabBackground.Color; + c.a = 0.5f; + EditorGUI.DrawRect(rect, c); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Graphics.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Graphics.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..72bcc8dec5a5093f8c0aad499bae6be5220790d4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Graphics.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4545bb65ccebf8040ac212d5792979b5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/KeyTraverser.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/KeyTraverser.cs new file mode 100644 index 0000000000000000000000000000000000000000..2f648683e3fccfa26a23dd5eaacccaaab3a0917e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/KeyTraverser.cs @@ -0,0 +1,203 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline.Utilities +{ + class KeyTraverser + { + float[] m_KeyCache; + int m_DirtyStamp = -1; + int m_LastHash = -1; + readonly TimelineAsset m_Asset; + readonly float m_Epsilon; + int m_LastIndex = -1; + + public int lastIndex + { + get { return m_LastIndex; } + } + + public static IEnumerable GetClipKeyTimes(TimelineClip clip) + { + if (clip == null || clip.animationClip == null || clip.animationClip.empty) + return new float[0]; + + return AnimationClipCurveCache.Instance.GetCurveInfo(clip.animationClip).keyTimes. + Select(k => (float)clip.FromLocalTimeUnbound(k)). // convert to sequence time + Where(k => k >= clip.start && k <= clip.end); // remove non visible keys + } + + public static IEnumerable GetTrackKeyTimes(AnimationTrack track) + { + if (track != null) + { + if (track.inClipMode) + return track.clips.Where(c => c.recordable). + SelectMany(x => GetClipKeyTimes(x)); + if (track.infiniteClip != null && !track.infiniteClip.empty) + return AnimationClipCurveCache.Instance.GetCurveInfo(track.infiniteClip).keyTimes; + } + return new float[0]; + } + + static int CalcAnimClipHash(TrackAsset asset) + { + int hash = 0; + if (asset != null) + { + AnimationTrack animTrack = asset as AnimationTrack; + if (animTrack != null) + { + for (var i = 0; i != animTrack.clips.Length; ++i) + { + hash ^= (animTrack.clips[i]).Hash(); + } + } + foreach (var subTrack in asset.GetChildTracks()) + { + if (subTrack != null) + hash ^= CalcAnimClipHash(subTrack); + } + } + return hash; + } + + internal static int CalcAnimClipHash(TimelineAsset asset) + { + int hash = 0; + foreach (var t in asset.GetRootTracks()) + { + if (t != null) + hash ^= CalcAnimClipHash(t); + } + return hash; + } + + void RebuildKeyCache() + { + m_KeyCache = m_Asset.flattenedTracks.Where(x => (x as AnimationTrack) != null) + .Cast() + .SelectMany(t => GetTrackKeyTimes(t)). + OrderBy(x => x).ToArray(); + + if (m_KeyCache.Length > 0) + { + float[] unique = new float[m_KeyCache.Length]; + unique[0] = m_KeyCache[0]; + int index = 0; + for (int i = 1; i < m_KeyCache.Length; i++) + { + if (m_KeyCache[i] - unique[index] > m_Epsilon) + { + index++; + unique[index] = m_KeyCache[i]; + } + } + m_KeyCache = unique; + Array.Resize(ref m_KeyCache, index + 1); + } + } + + public KeyTraverser(TimelineAsset timeline, float epsilon) + { + m_Asset = timeline; + m_Epsilon = epsilon; + } + + void CheckCache(int dirtyStamp) + { + int hash = CalcAnimClipHash(m_Asset); + if (dirtyStamp != m_DirtyStamp || hash != m_LastHash) + { + RebuildKeyCache(); + m_DirtyStamp = dirtyStamp; + m_LastHash = hash; + } + } + + public float GetNextKey(float key, int dirtyStamp) + { + CheckCache(dirtyStamp); + if (m_KeyCache.Length > 0) + { + if (key < m_KeyCache.Last() - m_Epsilon) + { + if (key > m_KeyCache[0] - m_Epsilon) + { + float t = key + m_Epsilon; + // binary search + int max = m_KeyCache.Length - 1; + int min = 0; + while (max - min > 1) + { + int imid = (min + max) / 2; + if (t > m_KeyCache[imid]) + min = imid; + else + max = imid; + } + m_LastIndex = max; + return m_KeyCache[max]; + } + + m_LastIndex = 0; + return m_KeyCache[0]; + } + if (key < m_KeyCache.Last() + m_Epsilon) + { + m_LastIndex = m_KeyCache.Length - 1; + return Mathf.Max(key, m_KeyCache.Last()); + } + } + m_LastIndex = -1; + return key; + } + + public float GetPrevKey(float key, int dirtyStamp) + { + CheckCache(dirtyStamp); + if (m_KeyCache.Length > 0) + { + if (key > m_KeyCache[0] + m_Epsilon) + { + if (key < m_KeyCache.Last() + m_Epsilon) + { + float t = key - m_Epsilon; + + // binary search + int max = m_KeyCache.Length - 1; + int min = 0; + while (max - min > 1) + { + int imid = (min + max) / 2; + if (t < m_KeyCache[imid]) + max = imid; + else + min = imid; + } + m_LastIndex = min; + return m_KeyCache[min]; + } + m_LastIndex = m_KeyCache.Length - 1; + return m_KeyCache.Last(); + } + if (key >= m_KeyCache[0] - m_Epsilon) + { + m_LastIndex = 0; + return Mathf.Min(key, m_KeyCache[0]); + } + } + m_LastIndex = -1; + return key; + } + + public int GetKeyCount(int dirtyStamp) + { + CheckCache(dirtyStamp); + return m_KeyCache.Length; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/KeyTraverser.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/KeyTraverser.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5ce97aa592fd027c572f84629c66fc60eef66f08 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/KeyTraverser.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4b57f909f22642d469a39e9628535312 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/MarkerModifier.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/MarkerModifier.cs new file mode 100644 index 0000000000000000000000000000000000000000..a2b688e33c1825104d9fa78c8a90fec88c1e2219 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/MarkerModifier.cs @@ -0,0 +1,66 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + static class MarkerModifier + { + public static void DeleteMarker(IMarker marker) + { + var trackAsset = marker.parent; + if (trackAsset != null) + { + SelectionManager.Remove(marker); + trackAsset.DeleteMarker(marker); + } + } + + public static IEnumerable CloneMarkersToParent(IEnumerable markers, TrackAsset parent) + { + if (!markers.Any()) return Enumerable.Empty(); + var clonedMarkers = new List(); + foreach (var marker in markers) + clonedMarkers.Add(CloneMarkerToParent(marker, parent)); + return clonedMarkers; + } + + public static IMarker CloneMarkerToParent(IMarker marker, TrackAsset parent) + { + var markerObject = marker as ScriptableObject; + if (markerObject == null) return null; + + var newMarkerObject = Object.Instantiate(markerObject); + AddMarkerToParent(newMarkerObject, parent); + + newMarkerObject.name = markerObject.name; + try + { + CustomTimelineEditorCache.GetMarkerEditor((IMarker)newMarkerObject).OnCreate((IMarker)newMarkerObject, marker); + } + catch (Exception e) + { + Debug.LogException(e); + } + + + return (IMarker)newMarkerObject; + } + + static void AddMarkerToParent(ScriptableObject marker, TrackAsset parent) + { + TimelineCreateUtilities.SaveAssetIntoObject(marker, parent); + TimelineUndo.RegisterCreatedObjectUndo(marker, "Duplicate Marker"); + UndoExtensions.RegisterTrack(parent, "Duplicate Marker"); + + if (parent != null) + { + parent.AddMarker(marker); + ((IMarker)marker).Initialize(parent); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/MarkerModifier.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/MarkerModifier.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..b16c6f5f4d5651ff953e5677eeac76b5800d566e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/MarkerModifier.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 7cfaad4e53832d94c9421d2dd1ad82f7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ObjectExtension.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ObjectExtension.cs new file mode 100644 index 0000000000000000000000000000000000000000..863500d1c208918c5eb43fd55f9f01ad65384597 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ObjectExtension.cs @@ -0,0 +1,28 @@ +using UnityEngine; +using UnityEditor; + +namespace UnityEditor.Timeline +{ + static class ObjectExtension + { + public static bool IsSceneObject(this Object obj) + { + if (obj == null) + return false; + + bool isSceneType = obj is GameObject || obj is Component; + if (!isSceneType) + return false; + + return !PrefabUtility.IsPartOfPrefabAsset(obj); + } + + public static bool IsPrefab(this Object obj) + { + if (obj == null) + return false; + + return PrefabUtility.IsPartOfPrefabAsset(obj); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ObjectExtension.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ObjectExtension.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..b1ff382473098e6542ea66b159d6e413e508fee4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ObjectExtension.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4722a1362908a1843ab03a055c5c3fa0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ObjectReferenceField.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ObjectReferenceField.cs new file mode 100644 index 0000000000000000000000000000000000000000..3ace197cc04c2664f927ed69182283759f7d69e0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ObjectReferenceField.cs @@ -0,0 +1,195 @@ +using System; +using System.Collections.Generic; +using System.Reflection; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEditor; +using UnityEditor.SceneManagement; +using UnityEngine.Playables; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + // Describes the object references on a ScriptableObject, ignoring script fields + struct ObjectReferenceField + { + public string propertyPath; + public bool isSceneReference; + public System.Type type; + + private readonly static ObjectReferenceField[] None = new ObjectReferenceField[0]; + private readonly static Dictionary s_Cache = new Dictionary(); + + public static ObjectReferenceField[] FindObjectReferences(System.Type type) + { + if (type == null) + return None; + + if (type.IsAbstract || type.IsInterface) + return None; + + if (!typeof(ScriptableObject).IsAssignableFrom(type)) + return None; + + ObjectReferenceField[] result = null; + if (s_Cache.TryGetValue(type, out result)) + return result; + + result = SearchForFields(type); + s_Cache[type] = result; + return result; + } + + public static ObjectReferenceField[] FindObjectReferences() where T : ScriptableObject, new() + { + return FindObjectReferences(typeof(T)); + } + + private static ObjectReferenceField[] SearchForFields(System.Type t) + { + Object instance = ScriptableObject.CreateInstance(t); + var list = new List(); + + var serializableObject = new SerializedObject(instance); + var prop = serializableObject.GetIterator(); + bool enterChildren = true; + while (prop.NextVisible(enterChildren)) + { + enterChildren = true; + var ppath = prop.propertyPath; + if (ppath == "m_Script") + { + enterChildren = false; + } + else if (prop.propertyType == SerializedPropertyType.ObjectReference || prop.propertyType == SerializedPropertyType.ExposedReference) + { + enterChildren = false; + var exposedType = GetTypeFromPath(t, prop.propertyPath); + if (exposedType != null && typeof(Object).IsAssignableFrom(exposedType)) + { + bool isSceneRef = prop.propertyType == SerializedPropertyType.ExposedReference; + list.Add( + new ObjectReferenceField() {propertyPath = prop.propertyPath, isSceneReference = isSceneRef, type = exposedType} + ); + } + } + } + + Object.DestroyImmediate(instance); + if (list.Count == 0) + return None; + return list.ToArray(); + } + + private static System.Type GetTypeFromPath(System.Type baseType, string path) + { + if (string.IsNullOrEmpty(path)) + return null; + + System.Type parentType = baseType; + FieldInfo field = null; + var pathTo = path.Split(new char[] {'.'}, StringSplitOptions.RemoveEmptyEntries); + var flags = BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic | + BindingFlags.Instance; + foreach (string s in pathTo) + { + field = parentType.GetField(s, flags); + while (field == null) + { + if (parentType.BaseType == null) + return null; // Should not happen really. Means SerializedObject got the property, but the reflection missed it + parentType = parentType.BaseType; + field = parentType.GetField(s, flags); + } + + parentType = field.FieldType; + } + + // dig out exposed reference types + if (field.FieldType.IsGenericType && field.FieldType.GetGenericTypeDefinition() == typeof(ExposedReference).GetGenericTypeDefinition()) + { + return field.FieldType.GetGenericArguments()[0]; + } + + return field.FieldType; + } + + public Object Find(ScriptableObject sourceObject, Object context = null) + { + if (sourceObject == null) + return null; + + SerializedObject obj = new SerializedObject(sourceObject, context); + var prop = obj.FindProperty(propertyPath); + if (prop == null) + throw new InvalidOperationException("sourceObject is not of the proper type. It does not contain a path to " + propertyPath); + + Object result = null; + if (isSceneReference) + { + if (prop.propertyType != SerializedPropertyType.ExposedReference) + throw new InvalidOperationException(propertyPath + " is marked as a Scene Reference, but is not an exposed reference type"); + if (context == null) + Debug.LogWarning("ObjectReferenceField.Find " + " is called on a scene reference without a context, will always be null"); + + result = prop.exposedReferenceValue; + } + else + { + if (prop.propertyType != SerializedPropertyType.ObjectReference) + throw new InvalidOperationException(propertyPath + "is marked as an asset reference, but is not an object reference type"); + result = prop.objectReferenceValue; + } + + return result; + } + + /// + /// Check if an Object satisfies this field, including components + /// + public bool IsAssignable(Object obj) + { + if (obj == null) + return false; + + // types match + bool potentialMatch = type.IsAssignableFrom(obj.GetType()); + + // field is component, and it exists on the gameObject + if (!potentialMatch && typeof(Component).IsAssignableFrom(type) && obj is GameObject) + potentialMatch = ((GameObject)obj).GetComponent(type) != null; + + return potentialMatch && isSceneReference == obj.IsSceneObject(); + } + + /// + /// Assigns a value to the field + /// + public bool Assign(ScriptableObject scriptableObject, Object value, IExposedPropertyTable exposedTable = null) + { + var serializedObject = new SerializedObject(scriptableObject, exposedTable as Object); + var property = serializedObject.FindProperty(propertyPath); + if (property == null) + return false; + + // if the value is a game object, but the field is a component + if (value is GameObject && typeof(Component).IsAssignableFrom(type)) + value = ((GameObject)value).GetComponent(type); + + if (isSceneReference) + { + property.exposedReferenceValue = value; + + // the object gets dirtied, but not the scene which is where the reference is stored + var component = exposedTable as Component; + if (component != null && !EditorApplication.isPlaying) + EditorSceneManager.MarkSceneDirty(component.gameObject.scene); + } + else + property.objectReferenceValue = value; + + serializedObject.ApplyModifiedProperties(); + return true; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ObjectReferenceField.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ObjectReferenceField.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..c0655c7337d12135d09d991e596347cd16ab7cb6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/ObjectReferenceField.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 29bf1d4ec1012bc45967ce95b729b8b3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/PropertyCollector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/PropertyCollector.cs new file mode 100644 index 0000000000000000000000000000000000000000..f19300d3c922621e0a6d7bd22ba6ad62e29a1707 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/PropertyCollector.cs @@ -0,0 +1,226 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class PropertyCollector : IPropertyCollector + { + readonly Stack m_ObjectStack = new Stack(); + + // Call immediately before use + public void Reset() + { + m_ObjectStack.Clear(); + } + + // call to reset caches. should be called when switching master timelines + public void Clear() + { + m_ObjectStack.Clear(); + AnimationPreviewUtilities.ClearCaches(); + } + + public void PushActiveGameObject(GameObject gameObject) + { + m_ObjectStack.Push(gameObject); + } + + public void PopActiveGameObject() + { + m_ObjectStack.Pop(); + } + + public void AddFromClip(AnimationClip clip) + { + var go = m_ObjectStack.Peek(); // allow it to throw if empty + if (go != null && clip != null) // null game object is allowed for calls to be ignored + AddFromClip(go, clip); + } + + public void AddFromClips(IEnumerable clips) + { + var go = m_ObjectStack.Peek(); + if (go != null) + AddFromClips(go, clips); + } + + public void AddFromName(string name) where T : Component + { + var go = m_ObjectStack.Peek(); // allow it to throw if empty + if (go != null) // null game object is allowed for calls to be ignored + AddFromName(go, name); + } + + public void AddFromName(string name) + { + var go = m_ObjectStack.Peek(); // allow it to throw if empty + if (go != null) // null game object is allowed for calls to be ignored + AddFromName(go, name); + } + + public void AddFromClip(GameObject obj, AnimationClip clip) + { + if (!Application.isPlaying) + AddPropertiesFromClip(obj, clip); + } + + public void AddFromClips(GameObject animatorRoot, IEnumerable clips) + { + if (Application.isPlaying) + return; + + AnimationPreviewUtilities.PreviewFromCurves(animatorRoot, AnimationPreviewUtilities.GetBindings(animatorRoot, clips)); + } + + public void AddFromName(GameObject obj, string name) where T : Component + { + if (!Application.isPlaying) + AddPropertiesFromName(obj, typeof(T), name); + } + + public void AddFromName(GameObject obj, string name) + { + if (!Application.isPlaying) + AddPropertiesFromName(obj, name); + } + + public void AddFromName(Component component, string name) + { + if (!Application.isPlaying) + AddPropertyModification(component, name); + } + + public void AddFromComponent(GameObject obj, Component component) + { + if (Application.isPlaying) + return; + + if (obj == null || component == null) + return; + + var serializedObject = new SerializedObject(component); + SerializedProperty property = serializedObject.GetIterator(); + + while (property.NextVisible(true)) + { + if (property.hasVisibleChildren || !AnimatedParameterUtility.IsTypeAnimatable(property.propertyType)) + continue; + + AddPropertyModification(component, property.propertyPath); + } + } + + void AddPropertiesFromClip(GameObject go, AnimationClip clip) + { + if (go != null && clip != null) + { + AnimationMode.InitializePropertyModificationForGameObject(go, clip); + } + } + + static void AddPropertiesFromName(GameObject go, string property) + { + if (go == null) + return; + + AddPropertyModification(go, property); + } + + static void AddPropertiesFromName(GameObject go, Type compType, string property) + { + if (go == null) + return; + var comp = go.GetComponent(compType); + if (comp == null) + return; + + AddPropertyModification(comp, property); + } + + public void AddObjectProperties(Object obj, AnimationClip clip) + { + if (obj == null || clip == null) + return; + + IPlayableAsset asset = obj as IPlayableAsset; + IPlayableBehaviour playable = obj as IPlayableBehaviour; + + // special case for assets that contain animated script playables. + // The paths in the clip start from the field with the templated playable + if (asset != null) + { + if (playable == null) + { + AddSerializedPlayableModifications(asset, clip); + } + else + { + // in this case the asset is the playable. The clip applies directly + AnimationMode.InitializePropertyModificationForObject(obj, clip); + } + } + } + + void AddSerializedPlayableModifications(IPlayableAsset asset, AnimationClip clip) + { + var obj = asset as Object; + if (obj == null) + return; + + var driver = WindowState.previewDriver; + if (driver == null || !AnimationMode.InAnimationMode(driver)) + return; + + var serializedObj = new SerializedObject(obj); + var bindings = AnimationClipCurveCache.Instance.GetCurveInfo(clip).bindings; + var fields = AnimatedParameterUtility.GetScriptPlayableFields(asset); + + // go through each binding and offset using the field name + // so the modification system can find the particle object using the asset as a root + foreach (var b in bindings) + { + foreach (var f in fields) + { + var propertyPath = f.Name + "." + b.propertyName; + if (serializedObj.FindProperty(propertyPath) != null) + { + DrivenPropertyManager.RegisterProperty(driver, obj, propertyPath); + break; + } + } + } + } + + private static void AddPropertyModification(GameObject obj, string propertyName) + { + var driver = WindowState.previewDriver; + if (driver == null || !AnimationMode.InAnimationMode(driver)) + return; + + DrivenPropertyManager.RegisterProperty(driver, obj, propertyName); + } + + private static void AddPropertyModification(Component comp, string name) + { + if (comp == null) + return; + + var driver = WindowState.previewDriver; + if (driver == null || !AnimationMode.InAnimationMode(driver)) + return; + + // Register Property will display an error if a property doesn't exist (wanted behaviour) + // However, it also displays an error on Monobehaviour m_Script property, since it can't be driven. (not wanted behaviour) + // case 967026 + if (name == "m_Script" && (comp as MonoBehaviour) != null) + return; + + DrivenPropertyManager.RegisterProperty(driver, comp, name); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/PropertyCollector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/PropertyCollector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..3e8f48690495f58ebad1c9ac0fd4a5dc6fd72137 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/PropertyCollector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1f3a562675833b4448299e4f627b0cec +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Range.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Range.cs new file mode 100644 index 0000000000000000000000000000000000000000..745e7420a5108657fd674a68655f7332df475acd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Range.cs @@ -0,0 +1,49 @@ +using System; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + struct Range + { + public double start; + public double end; + public double length { get { return end - start; } } + + public static Range Union(Range lhs, Range rhs) + { + return new Range + { + start = Math.Min(lhs.start, rhs.start), + end = Math.Max(lhs.end, rhs.end) + }; + } + + public static Range Intersection(Range lhs, Range rhs) + { + var s = Math.Max(lhs.start, rhs.start); + var e = Math.Min(lhs.end, rhs.end); + + if (s > e) + { + // No intersection returns a 0-length range from 0 to 0 + return new Range(); + } + + return new Range + { + start = s, + end = e + }; + } + + public override string ToString() + { + return ToString("F3"); + } + + public string ToString(string format) + { + return UnityString.Format("({0}, {1})", start.ToString(format), end.ToString(format)); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Range.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Range.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..22005c4a9fa6f29be992d7d808e6996d80930efa --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Range.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d31dfeaa131921f4eae00783cc48146f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes.meta new file mode 100644 index 0000000000000000000000000000000000000000..1eb0faa6b323fa80e6c06d75b6e993f211cb61e2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: d55400f78d024c05b04dc124bb181d9e +timeCreated: 1605887929 \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIColorOverride.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIColorOverride.cs new file mode 100644 index 0000000000000000000000000000000000000000..47815cd9fac7e7cf06a19de116dcced8f7a5f5e7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIColorOverride.cs @@ -0,0 +1,21 @@ +using System; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + struct GUIColorOverride : IDisposable + { + readonly Color m_OldColor; + + public GUIColorOverride(Color newColor) + { + m_OldColor = GUI.color; + GUI.color = newColor; + } + + public void Dispose() + { + GUI.color = m_OldColor; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIColorOverride.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIColorOverride.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1d338afd5cee2594e021b93258ed4e081d2e766f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIColorOverride.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 44507a833d0ca8a42aaec1c3d752eb5f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIGroupScope.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIGroupScope.cs new file mode 100644 index 0000000000000000000000000000000000000000..e8f04133d8bb71f4e548bde893cb0246d47705a0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIGroupScope.cs @@ -0,0 +1,18 @@ +using System; +using UnityEngine; + +namespace UnityEditor +{ + struct GUIGroupScope : IDisposable + { + public GUIGroupScope(Rect position) + { + GUI.BeginGroup(position); + } + + public void Dispose() + { + GUI.EndGroup(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIGroupScope.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIGroupScope.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..d0a2d09118517d3106ad24399a438bbfbcfbf400 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIGroupScope.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0bee8aba5e8a40446b7098666c5314d9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIMixedValueScope.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIMixedValueScope.cs new file mode 100644 index 0000000000000000000000000000000000000000..f3da9f31891049e90c3dc6afd6e4194e433c90ea --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIMixedValueScope.cs @@ -0,0 +1,20 @@ +using System; +using UnityEngine; + +namespace UnityEditor +{ + struct GUIMixedValueScope : IDisposable + { + readonly bool m_PrevValue; + public GUIMixedValueScope(bool newValue) + { + m_PrevValue = EditorGUI.showMixedValue; + EditorGUI.showMixedValue = newValue; + } + + public void Dispose() + { + EditorGUI.showMixedValue = m_PrevValue; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIMixedValueScope.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIMixedValueScope.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..94ff58698db9370d8acf5a08adaf54bd3464b522 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIMixedValueScope.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d59cefc45e3c31d4a90563364e7258fa +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIViewportScope.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIViewportScope.cs new file mode 100644 index 0000000000000000000000000000000000000000..7999ffd6b072e077d9455a74aa9f6b95af9faa51 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIViewportScope.cs @@ -0,0 +1,34 @@ +using System; +using UnityEngine; + +namespace UnityEditor +{ + // Special Clip Scope that only effects painting, and keeps the coordinate system identical + struct GUIViewportScope : IDisposable + { + bool m_open; + public GUIViewportScope(Rect position) + { + m_open = false; + if (Event.current.type == EventType.Repaint || Event.current.type == EventType.Layout) + { + GUI.BeginClip(position, -position.min, Vector2.zero, false); + m_open = true; + } + } + + public void Dispose() + { + CloseScope(); + } + + void CloseScope() + { + if (m_open) + { + GUI.EndClip(); + m_open = false; + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIViewportScope.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIViewportScope.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1c3a2f0df6beb1c33bd28d2ed3722136f628dd92 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/GUIViewportScope.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: af84cf39b8fa0654badd9278cbd00d77 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/HorizontalScope.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/HorizontalScope.cs new file mode 100644 index 0000000000000000000000000000000000000000..54c57bd4462a958b78a8eeca04eca2d14129255b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/HorizontalScope.cs @@ -0,0 +1,20 @@ +using System; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + readonly struct HorizontalScope : IDisposable + { + public readonly Rect rect; + + public HorizontalScope(GUIContent content, GUIStyle style) + { + rect = EditorGUILayout.BeginHorizontal(content, style); + } + + public void Dispose() + { + EditorGUILayout.EndHorizontal(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/HorizontalScope.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/HorizontalScope.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..3f9332f0fadda28f8fb2abdda82dda7d9fe32e4c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/HorizontalScope.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: 75e3737506434a75b1f7901d8883ad47 +timeCreated: 1605888588 \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/IndentLevelScope.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/IndentLevelScope.cs new file mode 100644 index 0000000000000000000000000000000000000000..598ca6294e398f21c7faa893929339734e5e9325 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/IndentLevelScope.cs @@ -0,0 +1,20 @@ +using System; + +namespace UnityEditor.Timeline +{ + readonly struct IndentLevelScope : IDisposable + { + readonly int m_PrevValue; + + public IndentLevelScope(int newValue) + { + m_PrevValue = EditorGUI.indentLevel; + EditorGUI.indentLevel = newValue; + } + + public void Dispose() + { + EditorGUI.indentLevel = m_PrevValue; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/IndentLevelScope.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/IndentLevelScope.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..92f732f45dd9dcc3724ae7c4043187f480dde660 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/IndentLevelScope.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: e42e3f559ace4a5dbae7d6d3d2e5e7b0 +timeCreated: 1605888248 \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/LabelWidthScope.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/LabelWidthScope.cs new file mode 100644 index 0000000000000000000000000000000000000000..5bb7367d89f1746a2c6f889290bc423360800f66 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/LabelWidthScope.cs @@ -0,0 +1,20 @@ +using System; + +namespace UnityEditor.Timeline +{ + readonly struct LabelWidthScope : IDisposable + { + readonly float m_PrevValue; + + public LabelWidthScope(float newValue) + { + m_PrevValue = EditorGUIUtility.labelWidth; + EditorGUIUtility.labelWidth = newValue; + } + + public void Dispose() + { + EditorGUIUtility.labelWidth = m_PrevValue; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/LabelWidthScope.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/LabelWidthScope.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..d10a0eae892c37e8cd3204bd641fd0f0428cf080 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/LabelWidthScope.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: 9d095bb54df44c01a27e76a2b060a072 +timeCreated: 1605888410 \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/PropertyScope.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/PropertyScope.cs new file mode 100644 index 0000000000000000000000000000000000000000..8c09675f38d4f11e9170811a315aaab59872360f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/PropertyScope.cs @@ -0,0 +1,20 @@ +using System; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + readonly struct PropertyScope : IDisposable + { + public readonly GUIContent content; + + public PropertyScope(Rect totalPosition, GUIContent label, SerializedProperty property) + { + content = EditorGUI.BeginProperty(totalPosition, label, property); + } + + public void Dispose() + { + EditorGUI.EndProperty(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/PropertyScope.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/PropertyScope.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..eae6bc4c8a74a10e05df7f602af55bf039a3047b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/Scopes/PropertyScope.cs.meta @@ -0,0 +1,3 @@ +fileFormatVersion: 2 +guid: 0ccfd55dae664bbcb54c8457acffdbf8 +timeCreated: 1605887959 \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/SequenceSelectorNameFormater.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/SequenceSelectorNameFormater.cs new file mode 100644 index 0000000000000000000000000000000000000000..654eecbcd12ce0432064495284bd4bda600d81fd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/SequenceSelectorNameFormater.cs @@ -0,0 +1,32 @@ +using System; +using System.Collections.Generic; + +namespace UnityEditor.Timeline +{ + // Class used for uniquely format names used in the GenericMenu. We can't add duplicate MenuItem in GenericMenu + // so that's why we need to keep information about the text we want to uniquely format. + class SequenceMenuNameFormater + { + Dictionary m_UniqueItem = new Dictionary(); + + public string Format(string text) + { + var key = text.GetHashCode(); + var index = 0; + + if (m_UniqueItem.ContainsKey(key)) + { + index = m_UniqueItem[key]; + index++; + m_UniqueItem[key] = index; + } + else + { + m_UniqueItem.Add(key, index); + return text; + } + + return $"{text}{index}"; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/SequenceSelectorNameFormater.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/SequenceSelectorNameFormater.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..9fe16bd67d820ec2db7d3cf6988d9736e10417b7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/SequenceSelectorNameFormater.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1861286ba69badd439188a65bebf3cda +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/SpacePartitioner.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/SpacePartitioner.cs new file mode 100644 index 0000000000000000000000000000000000000000..6fa1edc8f801977806a7b1ebc58c497599d069e1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/SpacePartitioner.cs @@ -0,0 +1,124 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + interface IBounds + { + Rect boundingRect { get; } + } + + class SpacePartitioner + { + internal class CachedList + { + public static readonly List Instance = new List(1000); + } + + struct Entry : IInterval + { + public object item { get; set; } + public long intervalStart { get; set; } + public long intervalEnd { get; set; } + public Rect bounds { get; set; } + + private const float kPrecision = 100.0f; + private const float kMaxFloat = (float)long.MaxValue; + private const float kMinFloat = (float)long.MinValue; + + static public Int64 FromFloat(float f) + { + if (Single.IsPositiveInfinity(f)) + return long.MaxValue; + if (Single.IsNegativeInfinity(f)) + return long.MinValue; + + f = Mathf.Clamp(f, kMinFloat, kMaxFloat); // prevent overflow of floats + f = Mathf.Clamp(f * kPrecision, kMinFloat, kMaxFloat); // clamp to 'long' range + return (long)(f); + } + } + + const EventType k_GuiEventLock = EventType.Repaint; + + IntervalTree m_Tree = new IntervalTree(); + List m_CacheList = new List(); + + public void Clear() + { + m_Tree.Clear(); + } + + public void AddBounds(IBounds bounds) + { + AddBounds(bounds, bounds.boundingRect); + } + + public void AddBounds(object item, Rect rect) + { + if (item == null) + throw new ArgumentNullException("item"); + + m_Tree.Add(new Entry() + { + intervalStart = Entry.FromFloat(rect.yMin), + intervalEnd = Entry.FromFloat(rect.yMax), + bounds = rect, + item = item + } + ); + } + + /// + /// Get items of type T at a given position + /// + /// + /// + /// + /// + /// Uses a (1,1) sized box + /// Use .ToList() or .ToArray() when not enumerating the result immediately + /// + /// + public IEnumerable GetItemsAtPosition(Vector2 position) + { + return GetItemsInArea(new Rect(position.x, position.y, 1, 1)); + } + + /// + /// + /// + /// + /// + /// + /// + public IEnumerable GetItemsInArea(Rect area) + { + m_CacheList.Clear(); + m_Tree.IntersectsWithRange(long.MinValue, long.MaxValue, m_CacheList); + + var list = CachedList.Instance; + list.Clear(); + foreach (var i in m_CacheList) + { + if (i.item is T && i.bounds.Overlaps(area)) + list.Add((T)i.item); + } + return list; + } + + public void DebugDraw(Color fillColor, Color outlineColor) + { + m_CacheList.Clear(); + m_Tree.IntersectsWithRange(long.MinValue, long.MaxValue, m_CacheList); + HandleUtility.ApplyWireMaterial(); + + foreach (var item in m_CacheList) + { + Handles.DrawSolidRectangleWithOutline(item.bounds, fillColor, outlineColor); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/SpacePartitioner.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/SpacePartitioner.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2359caeac298697390fa1f4246cfd27ecfe4fa21 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/SpacePartitioner.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2fa2cf7de51b0d34d9dce3747b72e49d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/StyleManager.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/StyleManager.cs new file mode 100644 index 0000000000000000000000000000000000000000..794fc68fef7b0f86e8c7cec34fed4bd3cc30ae9e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/StyleManager.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.Experimental; +using UnityEditor.StyleSheets; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class StyleManager + { + static readonly StyleState[] k_StyleStates = { StyleState.any }; + static readonly string k_ErrorCannotFindStyle = L10n.Tr("Cannot find style {0} for {1}"); + + static Dictionary s_CustomStyles = new Dictionary(); + static GUISkin s_CurrentSkin; + + public static GUIStyle UssStyleForType(Type type) + { + ClearCacheIfInvalid(); + + GUIStyle cachedStyle; + if (s_CustomStyles.TryGetValue(type, out cachedStyle)) + return cachedStyle; + + var style = DirectorStyles.GetGUIStyle(DirectorStyles.markerDefaultStyle); + + var customStyleForType = CustomStyleForType(type); + if (customStyleForType != null) + { + if (IsStyleValid(customStyleForType)) + style = DirectorStyles.GetGUIStyle(customStyleForType); + else + Debug.LogWarningFormat(k_ErrorCannotFindStyle, customStyleForType, type.Name); + } + + s_CustomStyles.Add(type, style); + return style; + } + + static string CustomStyleForType(Type type) + { + var attr = (CustomStyleAttribute)type.GetCustomAttributes(typeof(CustomStyleAttribute), true).FirstOrDefault(); + return attr != null ? attr.ussStyle : null; + } + + static bool IsStyleValid(string ussStyle) + { + return GUISkin.current.FindStyle(ussStyle) != null || EditorResources.styleCatalog.GetStyle(ussStyle, k_StyleStates).IsValid(); + } + + static void ClearCacheIfInvalid() + { + if (s_CurrentSkin != GUISkin.current) + s_CustomStyles.Clear(); + s_CurrentSkin = GUISkin.current; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/StyleManager.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/StyleManager.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..bba0d357ef4ac164225725f165006ef9bce23153 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/StyleManager.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5f31f28cc64c91042976555c016ffd5f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/StyleNormalColorOverride.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/StyleNormalColorOverride.cs new file mode 100644 index 0000000000000000000000000000000000000000..24016caac86f9fc6805baa38c8780d56ea6c3cf5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/StyleNormalColorOverride.cs @@ -0,0 +1,23 @@ +using System; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + struct StyleNormalColorOverride : IDisposable + { + readonly GUIStyle m_Style; + readonly Color m_OldColor; + + public StyleNormalColorOverride(GUIStyle style, Color newColor) + { + m_Style = style; + m_OldColor = style.normal.textColor; + style.normal.textColor = newColor; + } + + public void Dispose() + { + m_Style.normal.textColor = m_OldColor; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/StyleNormalColorOverride.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/StyleNormalColorOverride.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..b96931149f2bdaacd0f726495239651fd0953fbf --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/StyleNormalColorOverride.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2bd3ca1fde4b154448ef972b0f9d292e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TimeReferenceUtility.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TimeReferenceUtility.cs new file mode 100644 index 0000000000000000000000000000000000000000..80986b442fb3c68b81764e1fde944e3f5b010822 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TimeReferenceUtility.cs @@ -0,0 +1,78 @@ +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class TimeReferenceUtility + { + static WindowState state { get { return TimelineWindow.instance.state; } } + + public static float PixelToTime(Vector2 mousePos) + { + return PixelToTime(mousePos.x); + } + + public static float PixelToTime(float pixelX) + { + return state.PixelToTime(pixelX); + } + + public static double GetSnappedTimeAtMousePosition(Vector2 mousePos) + { + return state.GetSnappedTimeAtMousePosition(mousePos); + } + + public static double SnapToFrameIfRequired(double currentTime) + { + return TimelinePreferences.instance.snapToFrame ? SnapToFrame(currentTime) : currentTime; + } + + public static double SnapToFrame(double time) + { + if (state.timeReferenceMode == TimeReferenceMode.Global) + { + time = state.editSequence.ToGlobalTime(time); + time = TimeUtility.RoundToFrame(time, state.referenceSequence.frameRate); + return state.editSequence.ToLocalTime(time); + } + + return TimeUtility.RoundToFrame(time, state.referenceSequence.frameRate); + } + + public static string ToTimeString(double time, string format = "F2") + { + if (state.timeReferenceMode == TimeReferenceMode.Global) + time = state.editSequence.ToGlobalTime(time); + + return state.timeInFrames ? + TimeUtility.TimeAsFrames(time, state.referenceSequence.frameRate, format) : + TimeUtility.TimeAsTimeCode(time, state.referenceSequence.frameRate, format); + } + + public static double FromTimeString(string timeString) + { + double newTime; + + if (state.timeInFrames) + { + double newFrameDouble; + if (double.TryParse(timeString, out newFrameDouble)) + newTime = TimeUtility.FromFrames(newFrameDouble, state.referenceSequence.frameRate); + else + newTime = state.editSequence.time; + } + else + { + newTime = TimeUtility.ParseTimeCode(timeString, state.referenceSequence.frameRate, -1); + } + + if (newTime >= 0.0) + { + return state.timeReferenceMode == TimeReferenceMode.Global ? + state.editSequence.ToLocalTime(newTime) : newTime; + } + + return state.editSequence.time; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TimeReferenceUtility.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TimeReferenceUtility.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1da1a4afd574c21170436ad31a3cdc66c46cebe7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TimeReferenceUtility.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f6bb32665bcc91b41a7177fd6af08ad6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TimelineKeyboardNavigation.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TimelineKeyboardNavigation.cs new file mode 100644 index 0000000000000000000000000000000000000000..2074fb711d3d77386712947d346a9bbb45773bd0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TimelineKeyboardNavigation.cs @@ -0,0 +1,404 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.IMGUI.Controls; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class KeyboardNavigation + { + public static void FrameTrackHeader(TreeViewItem treeItem = null) + { + if (TrackHeadActive()) + treeItem = treeItem ?? SelectionManager.SelectedTrackGUI().Last(); + else + { + var item = GetVisibleSelectedItems().LastOrDefault(); + treeItem = TimelineWindow.instance.allTracks.FirstOrDefault( + x => item != null && x.track == item.parentTrack); + } + + if (treeItem != null) + TimelineWindow.instance.treeView.FrameItem(treeItem); + } + + public static bool TrackHeadActive() + { + return SelectionManager.SelectedTracks().Any(x => x.IsVisibleRecursive()) && !ClipAreaActive(); + } + + public static bool ClipAreaActive() + { + return GetVisibleSelectedItems().Any(); + } + + public static IEnumerable GetVisibleSelectedItems() + { + return SelectionManager.SelectedItems().Where(x => x.parentTrack.IsVisibleRecursive()); + } + + public static IEnumerable GetVisibleTracks() + { + return TimelineWindow.instance.allTracks.Where(x => x.track.IsVisibleRecursive()); + } + + static TrackAsset PreviousTrack(this TrackAsset track) + { + var uiOrderTracks = GetVisibleTracks().Select(t => t.track).ToList(); + var selIdx = uiOrderTracks.IndexOf(track); + return selIdx > 0 ? uiOrderTracks[selIdx - 1] : null; + } + + static TrackAsset NextTrack(this TrackAsset track) + { + var uiOrderTracks = GetVisibleTracks().Select(t => t.track).ToList(); + var selIdx = uiOrderTracks.IndexOf(track); + return selIdx < uiOrderTracks.Count - 1 && selIdx != -1 ? uiOrderTracks[selIdx + 1] : null; + } + + static ITimelineItem PreviousItem(this ITimelineItem item, bool clipOnly) + { + var items = item.parentTrack.GetItems().ToArray(); + if (clipOnly) + { + items = items.Where(x => x is ClipItem).ToArray(); + } + else + { + items = items.Where(x => x is MarkerItem).ToArray(); + } + + var idx = Array.IndexOf(items, item); + return idx > 0 ? items[idx - 1] : null; + } + + static ITimelineItem NextItem(this ITimelineItem item, bool clipOnly) + { + var items = item.parentTrack.GetItems().ToArray(); + if (clipOnly) + { + items = items.Where(x => x is ClipItem).ToArray(); + } + else + { + items = items.Where(x => x is MarkerItem).ToArray(); + } + + var idx = Array.IndexOf(items, item); + return idx < items.Length - 1 ? items[idx + 1] : null; + } + + static bool FilterItems(ref List items) + { + var clipOnly = false; + if (items.Any(x => x is ClipItem)) + { + items = items.Where(x => x is ClipItem).ToList(); + clipOnly = true; + } + + return clipOnly; + } + + static ITimelineItem GetClosestItem(TrackAsset track, ITimelineItem refItem) + { + var start = refItem.start; + var end = refItem.end; + var items = track.GetItems().ToList(); + + if (refItem is ClipItem) + { + items = items.Where(x => x is ClipItem).ToList(); + } + else + { + items = items.Where(x => x is MarkerItem).ToList(); + } + + if (!items.Any()) + return null; + ITimelineItem ret = null; + var scoreToBeat = double.NegativeInfinity; + + foreach (var item in items) + { + // test for overlap + var low = Math.Max(item.start, start); + var high = Math.Min(item.end, end); + if (low <= high) + { + var score = high - low; + if (score >= scoreToBeat) + { + scoreToBeat = score; + ret = item; + } + } + } + + return ret; + } + + public static bool FocusFirstVisibleItem(IEnumerable focusTracks = null) + { + var timeRange = TimelineEditor.visibleTimeRange; + + var tracks = focusTracks ?? TimelineWindow.instance.treeView.visibleTracks.Where(x => x.IsVisibleRecursive() && x.GetItems().Any()); + var items = tracks.SelectMany(t => t.GetItems().OfType().Where(x => x.end >= timeRange.x && x.end <= timeRange.y || + x.start >= timeRange.x && x.start <= timeRange.y)).ToList(); + var itemFullyInView = items.Where(x => x.end >= timeRange.x && x.end <= timeRange.y && + x.start >= timeRange.x && x.start <= timeRange.y); + var itemToSelect = itemFullyInView.FirstOrDefault() ?? items.FirstOrDefault(); + if (itemToSelect != null && !itemToSelect.parentTrack.lockedInHierarchy) + { + SelectionManager.SelectOnly(itemToSelect); + return true; + } + return false; + } + + public static bool CollapseGroup(IEnumerable tracks) + { + if (!TrackHeadActive()) + return false; + + var didCollapse = false; + + foreach (TrackAsset track in tracks) + { + if (!track.GetChildTracks().Any()) + continue; + + if (!track.GetCollapsed()) + { + didCollapse = true; + track.SetCollapsed(true); + } + } + + if (didCollapse) + { + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + return true; + } + + return SelectAndShowParentTrack(tracks.LastOrDefault()); + } + + static bool SelectAndShowParentTrack(TrackAsset track) + { + TrackAsset parent = track != null ? track.parent as TrackAsset : null; + if (parent) + { + SelectionManager.SelectOnly(parent); + FrameTrackHeader(GetVisibleTracks().First(x => x.track == parent)); + return true; + } + + return false; + } + + public static bool SelectLeftItem(bool shift = false) + { + if (ClipAreaActive()) + { + var items = SelectionManager.SelectedItems().ToList(); + var clipOnly = FilterItems(ref items); + + var item = items.Last(); + var prev = item.PreviousItem(clipOnly); + if (prev != null && !prev.parentTrack.lockedInHierarchy) + { + if (shift) + { + if (SelectionManager.Contains(prev)) + SelectionManager.Remove(item); + SelectionManager.Add(prev); + } + else + SelectionManager.SelectOnly(prev); + TimelineHelpers.FrameItems(new[] {prev}); + } + else if (item != null && !shift && item.parentTrack != TimelineEditor.inspectedAsset.markerTrack) + SelectionManager.SelectOnly(item.parentTrack); + return true; + } + return false; + } + + public static bool SelectRightItem(bool shift = false) + { + if (ClipAreaActive()) + { + var items = SelectionManager.SelectedItems().ToList(); + var clipOnly = FilterItems(ref items); + + var item = items.Last(); + var next = item.NextItem(clipOnly); + if (next != null && !next.parentTrack.lockedInHierarchy) + { + if (shift) + { + if (SelectionManager.Contains(next)) + SelectionManager.Remove(item); + SelectionManager.Add(next); + } + else + SelectionManager.SelectOnly(next); + TimelineHelpers.FrameItems(new[] {next}); + return true; + } + } + return false; + } + + public static bool UnCollapseGroup(IEnumerable tracks) + { + if (!TrackHeadActive()) + return false; + + var didUncollapse = false; + foreach (TrackAsset track in tracks) + { + if (!track.GetChildTracks().Any()) + continue; + + if (track.GetCollapsed()) + { + didUncollapse = true; + track.SetCollapsed(false); + } + } + + if (didUncollapse) + { + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + return true; + } + + return SelectFirstClipStartingFrom(tracks.Last()); + } + + static bool SelectFirstClipStartingFrom(TrackAsset track) + { + List visibleTracks = GetVisibleTracks().Select(x => x.track).ToList(); + int idx = visibleTracks.IndexOf(track); + ITimelineItem item = null; + for (int i = idx; i < visibleTracks.Count; ++i) + { + var items = visibleTracks[i].GetItems().OfType(); + if (!items.Any() || visibleTracks[i].lockedInHierarchy) + continue; + item = items.First(); + break; + } + + if (item != null) + { + SelectionManager.SelectOnly(item); + TimelineHelpers.FrameItems(new[] { item }); + return true; + } + + return false; + } + + public static bool SelectUpTrack(bool shift = false) + { + if (TrackHeadActive()) + { + var prevTrack = PreviousTrack(SelectionManager.SelectedTracks().Last()); + if (prevTrack != null) + { + if (shift) + { + if (SelectionManager.Contains(prevTrack)) + SelectionManager.Remove(SelectionManager.SelectedTracks().Last()); + SelectionManager.Add(prevTrack); + } + else + SelectionManager.SelectOnly(prevTrack); + FrameTrackHeader(GetVisibleTracks().First(x => x.track == prevTrack)); + } + return true; + } + return false; + } + + public static bool SelectUpItem() + { + if (ClipAreaActive()) + { + var refItem = SelectionManager.SelectedItems().Last(); + var prevTrack = refItem.parentTrack.PreviousTrack(); + while (prevTrack != null) + { + var selectionItem = GetClosestItem(prevTrack, refItem); + if (selectionItem == null || prevTrack.lockedInHierarchy) + { + prevTrack = prevTrack.PreviousTrack(); + continue; + } + + SelectionManager.SelectOnly(selectionItem); + TimelineHelpers.FrameItems(new[] {selectionItem}); + FrameTrackHeader(GetVisibleTracks().First(x => x.track == selectionItem.parentTrack)); + break; + } + return true; + } + + return false; + } + + public static bool SelectDownTrack(bool shift = false) + { + if (TrackHeadActive()) + { + var nextTrack = SelectionManager.SelectedTracks().Last().NextTrack(); + if (nextTrack != null) + { + if (shift) + { + if (SelectionManager.Contains(nextTrack)) + SelectionManager.Remove(SelectionManager.SelectedTracks().Last()); + SelectionManager.Add(nextTrack); + } + else + SelectionManager.SelectOnly(nextTrack); + + FrameTrackHeader(GetVisibleTracks().First(x => x.track == nextTrack)); + } + return true; + } + + return false; + } + + public static bool SelectDownItem() + { + if (ClipAreaActive()) + { + var refItem = SelectionManager.SelectedItems().Last(); + var nextTrack = refItem.parentTrack.NextTrack(); + while (nextTrack != null) + { + var selectionItem = GetClosestItem(nextTrack, refItem); + if (selectionItem == null || nextTrack.lockedInHierarchy) + { + nextTrack = nextTrack.NextTrack(); + continue; + } + + SelectionManager.SelectOnly(selectionItem); + TimelineHelpers.FrameItems(new[] {selectionItem}); + FrameTrackHeader(GetVisibleTracks().First(x => x.track == selectionItem.parentTrack)); + break; + } + return true; + } + return false; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TimelineKeyboardNavigation.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TimelineKeyboardNavigation.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..7fb6aea888d130402e43ca04f44d6fd49b24df8d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TimelineKeyboardNavigation.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9be6112c2b1c3ae44927680ba7b36e10 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TrackModifier.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TrackModifier.cs new file mode 100644 index 0000000000000000000000000000000000000000..5afeb523500e835bbf58f94a00102c6908a1bedc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TrackModifier.cs @@ -0,0 +1,21 @@ +using UnityEngine; +using UnityEditor; +using UnityEngine.Timeline; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + static class TrackModifier + { + public static bool DeleteTrack(TimelineAsset timeline, TrackAsset track) + { + if (TimelineEditor.inspectedDirector != null) + { + TimelineUndo.PushUndo(TimelineEditor.inspectedDirector, "Delete Track"); + TimelineEditor.inspectedDirector.ClearGenericBinding(track); + } + + return timeline.DeleteTrack(track); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TrackModifier.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TrackModifier.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..f221e1008f65c7b1dc077502849d58a4700f8492 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TrackModifier.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 411b7c7ffc0960249b35a2a247b66ff7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TrackResourceCache.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TrackResourceCache.cs new file mode 100644 index 0000000000000000000000000000000000000000..1e8b67f124806e6f9d0ea39dec746e369878595b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TrackResourceCache.cs @@ -0,0 +1,132 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + static class TrackResourceCache + { + private static Dictionary s_TrackIconCache = new Dictionary(10); + private static Dictionary s_TrackColorCache = new Dictionary(10); + public static GUIContent s_DefaultIcon = EditorGUIUtility.IconContent("UnityEngine/ScriptableObject Icon"); + + public static GUIContent GetTrackIcon(TrackAsset track) + { + if (track == null) + return s_DefaultIcon; + + GUIContent content = null; + if (!s_TrackIconCache.TryGetValue(track.GetType(), out content)) + { + content = FindTrackIcon(track); + s_TrackIconCache[track.GetType()] = content; + } + return content; + } + + public static Texture2D GetTrackIconForType(System.Type trackType) + { + if (trackType == null || !typeof(TrackAsset).IsAssignableFrom(trackType)) + return null; + + GUIContent content; + if (!s_TrackIconCache.TryGetValue(trackType, out content) || content.image == null) + return s_DefaultIcon.image as Texture2D; + return content.image as Texture2D; + } + + public static Color GetTrackColor(TrackAsset track) + { + if (track == null) + return Color.white; + + // Try to ensure DirectorStyles is initialized first + // Note: GUISkin.current must exist to be able do so + if (!DirectorStyles.IsInitialized && GUISkin.current != null) + DirectorStyles.ReloadStylesIfNeeded(); + + Color color; + if (!s_TrackColorCache.TryGetValue(track.GetType(), out color)) + { + var attr = track.GetType().GetCustomAttributes(typeof(TrackColorAttribute), true); + if (attr.Length > 0) + { + color = ((TrackColorAttribute)attr[0]).color; + } + else + { + // case 1141958 + // There was an error initializing DirectorStyles + if (!DirectorStyles.IsInitialized) + return Color.white; + + color = DirectorStyles.Instance.customSkin.colorDefaultTrackDrawer; + } + + s_TrackColorCache[track.GetType()] = color; + } + return color; + } + + public static void ClearTrackIconCache() + { + s_TrackIconCache.Clear(); + } + + public static void SetTrackIcon(GUIContent content) where T : TrackAsset + { + s_TrackIconCache[typeof(T)] = content; + } + + public static void ClearTrackColorCache() + { + s_TrackColorCache.Clear(); + } + + public static void SetTrackColor(Color c) where T : TrackAsset + { + s_TrackColorCache[typeof(T)] = c; + } + + private static GUIContent FindTrackIcon(TrackAsset track) + { + // backwards compatible -- try to load from Gizmos folder + Texture2D texture = AssetDatabase.LoadAssetAtPath("Assets/Gizmos/" + track.GetType().Name + ".png"); + if (texture != null) + return new GUIContent(texture); + + // try to load based on the binding type + var binding = track.outputs.FirstOrDefault(); + if (binding.outputTargetType != null) + { + // Type calls don't properly handle monobehaviours, because an instance is required to + // get the monoscript icons + if (typeof(MonoBehaviour).IsAssignableFrom(binding.outputTargetType)) + { + texture = null; + var scripts = UnityEngine.Resources.FindObjectsOfTypeAll(); + foreach (var script in scripts) + { + if (script.GetClass() == binding.outputTargetType) + { + texture = AssetPreview.GetMiniThumbnail(script); + break; + } + } + } + else + { + texture = EditorGUIUtility.FindTexture(binding.outputTargetType); + } + + if (texture != null) + return new GUIContent(texture); + } + + // default to the scriptable object icon + return s_DefaultIcon; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TrackResourceCache.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TrackResourceCache.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..be2a51925aa68a54ba9044f86b439e76a9f2fa6b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TrackResourceCache.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 63f2caa33e79582448112b2e286d576d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TypeUtility.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TypeUtility.cs new file mode 100644 index 0000000000000000000000000000000000000000..9319feab51b3192e4d1fb2217f7ae5a02f2259c3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TypeUtility.cs @@ -0,0 +1,342 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Linq; +using System.Reflection; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; +using Component = UnityEngine.Component; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + static class TypeUtility + { + private static Type[] s_AllTrackTypes; + private static Type[] s_AllClipTypes; + private static Type[] s_MarkerTypes; + private static Dictionary s_TrackTypeToVisibleClipType = new Dictionary(); + private static Dictionary s_TrackTypeToAllClipType = new Dictionary(); + private static Dictionary s_TrackToBindingCache = new Dictionary(); + + public static bool IsConcretePlayableAsset(Type t) + { + return typeof(IPlayableAsset).IsAssignableFrom(t) + && IsConcreteAsset(t); + } + + private static bool IsConcreteAsset(Type t) + { + return typeof(ScriptableObject).IsAssignableFrom(t) + && !t.IsAbstract + && !t.IsGenericType + && !t.IsInterface + && !typeof(TrackAsset).IsAssignableFrom(t) + && !typeof(TimelineAsset).IsAssignableFrom(t); + } + + /// + /// List of all PlayableAssets + /// + public static IEnumerable AllClipTypes() + { + if (s_AllClipTypes == null) + { + s_AllClipTypes = TypeCache.GetTypesDerivedFrom(). + Where(t => IsConcreteAsset(t)). + ToArray(); + } + return s_AllClipTypes; + } + + public static IEnumerable AllTrackTypes() + { + if (s_AllTrackTypes == null) + { + s_AllTrackTypes = TypeCache.GetTypesDerivedFrom() + .Where(x => !x.IsAbstract) + .ToArray(); + } + + return s_AllTrackTypes; + } + + public static IEnumerable GetVisiblePlayableAssetsHandledByTrack(Type trackType) + { + if (trackType == null || !typeof(TrackAsset).IsAssignableFrom(trackType)) + return Enumerable.Empty(); + + Type[] types; + if (s_TrackTypeToVisibleClipType.TryGetValue(trackType, out types)) + { + return types; + } + + // special case -- the playable track handles all types not handled by other tracks + if (trackType == typeof(PlayableTrack)) + { + types = GetUnhandledClipTypes().ToArray(); + s_TrackTypeToVisibleClipType[trackType] = types; + return types; + } + + var attributes = trackType.GetCustomAttributes(typeof(TrackClipTypeAttribute), true); + var baseClasses = attributes. + OfType(). + Where(t => t.allowAutoCreate). + Select(a => a.inspectedType); + + types = AllClipTypes().Where(t => baseClasses.Any(x => x.IsAssignableFrom(t))).ToArray(); + s_TrackTypeToVisibleClipType[trackType] = types; + return types; + } + + public static IEnumerable GetPlayableAssetsHandledByTrack(Type trackType) + { + if (trackType == null || !typeof(TrackAsset).IsAssignableFrom(trackType)) + return Enumerable.Empty(); + + Type[] types; + if (s_TrackTypeToAllClipType.TryGetValue(trackType, out types)) + { + return types; + } + + // special case -- the playable track handles all types not handled by other tracks + if (trackType == typeof(PlayableTrack)) + { + types = GetUnhandledClipTypes().ToArray(); + s_TrackTypeToAllClipType[trackType] = types; + return types; + } + + var attributes = trackType.GetCustomAttributes(typeof(TrackClipTypeAttribute), true); + var baseClasses = attributes. + OfType(). + Select(a => a.inspectedType); + + types = AllClipTypes().Where(t => baseClasses.Any(x => x.IsAssignableFrom(t))).ToArray(); + s_TrackTypeToAllClipType[trackType] = types; + return types; + } + + /// + /// Returns the binding attribute attrached to the track + /// + public static TrackBindingTypeAttribute GetTrackBindingAttribute(Type trackType) + { + if (trackType == null || !typeof(TrackAsset).IsAssignableFrom(trackType)) + return null; + + TrackBindingTypeAttribute attribute = null; + if (!s_TrackToBindingCache.TryGetValue(trackType, out attribute)) + { + attribute = (TrackBindingTypeAttribute)Attribute.GetCustomAttribute(trackType, typeof(TrackBindingTypeAttribute)); + s_TrackToBindingCache.Add(trackType, attribute); + } + + return attribute; + } + + /// + /// True if the given track has a clip type that handles the given object + /// + public static bool TrackHasClipForObject(Type trackType, Object obj) + { + return GetPlayableAssetsHandledByTrack(trackType) + .Any(c => ObjectReferenceField.FindObjectReferences(c).Any(o => o.IsAssignable(obj))); + } + + /// + /// Get the list of markers that have fields for the object + /// + public static IEnumerable MarkerTypesWithFieldForObject(Object obj) + { + return GetAllMarkerTypes().Where( + c => ObjectReferenceField.FindObjectReferences(c).Any(o => o.IsAssignable(obj)) + ); + } + + /// + /// Get the list of tracks that can handle this object as clips + /// + public static IEnumerable GetTrackTypesForObject(Object obj) + { + if (obj == null) + return Enumerable.Empty(); + + return AllTrackTypes().Where(t => TrackHasClipForObject(t, obj)); + } + + /// + /// Given a trackType and an object, does the binding type match + /// Takes into account whether creating a missing component is permitted + /// + public static bool IsTrackCreatableFromObject(Object obj, Type trackType) + { + if (obj == null || obj.IsPrefab()) + return false; + + var attribute = GetTrackBindingAttribute(trackType); + if (attribute == null || attribute.type == null) + return false; + + if (attribute.type.IsAssignableFrom(obj.GetType())) + return true; + + var gameObject = obj as GameObject; + if (gameObject != null && typeof(Component).IsAssignableFrom(attribute.type)) + { + return gameObject.GetComponent(attribute.type) != null || + (attribute.flags & TrackBindingFlags.AllowCreateComponent) != 0; + } + + return false; + } + + /// + /// Given an object, get the list of track that are creatable from it. Takes + /// binding flags into account + /// + public static IEnumerable GetTracksCreatableFromObject(Object obj) + { + if (obj == null) + return Enumerable.Empty(); + + return AllTrackTypes().Where(t => !IsHiddenInMenu(t) && IsTrackCreatableFromObject(obj, t)); + } + + /// + /// Get the list of playable assets that can handle an object for a particular track + /// + /// The type of the track + /// The object to handle + /// + public static IEnumerable GetAssetTypesForObject(Type trackType, Object obj) + { + if (obj == null) + return Enumerable.Empty(); + + return GetPlayableAssetsHandledByTrack(trackType).Where( + c => ObjectReferenceField.FindObjectReferences(c).Any(o => o.IsAssignable(obj)) + ); + } + + // get the track types for a track from it's attributes + private static IEnumerable GetTrackClipTypesFromAttributes(Type trackType) + { + if (trackType == null || !typeof(TrackAsset).IsAssignableFrom(trackType)) + return Enumerable.Empty(); + + var attributes = trackType.GetCustomAttributes(typeof(TrackClipTypeAttribute), true); + var baseClasses = attributes. + OfType(). + Select(a => a.inspectedType); + + return AllClipTypes().Where(t => baseClasses.Any(x => x.IsAssignableFrom(t))); + } + + // find the playable asset types that are unhandled + private static IEnumerable GetUnhandledClipTypes() + { + var typesHandledByTrack = AllTrackTypes().SelectMany(t => GetTrackClipTypesFromAttributes(t)); + + // exclude anything in the timeline assembly, handled by tracks, has a hide in menu attribute + // or is explicity ignored + return AllClipTypes() + .Except(typesHandledByTrack) + .Where(t => !TypeUtility.IsBuiltIn(t)) // exclude built-in + .Where(t => !typeof(TrackAsset).IsAssignableFrom(t)) // exclude track types (they are playable assets) + .Where(t => !t.IsDefined(typeof(HideInMenuAttribute), false) && !t.IsDefined(typeof(IgnoreOnPlayableTrackAttribute), true)) + .Distinct(); + } + + public static IEnumerable GetAllMarkerTypes() + { + if (s_MarkerTypes == null) + { + s_MarkerTypes = TypeCache.GetTypesDerivedFrom() + .Where(x => + typeof(ScriptableObject).IsAssignableFrom(x) + && !x.IsAbstract + && !x.IsGenericType + && !x.IsInterface) + .ToArray(); + } + return s_MarkerTypes; + } + + public static IEnumerable GetUserMarkerTypes() + { + return GetAllMarkerTypes().Where(x => !IsBuiltIn(x) && !IsHiddenInMenu(x)); + } + + public static IEnumerable GetBuiltInMarkerTypes() + { + return GetAllMarkerTypes().Where(TypeUtility.IsBuiltIn); + } + + public static bool DoesTrackSupportMarkerType(TrackAsset track, Type type) + { + if (track.supportsNotifications) + { + return true; + } + + return !typeof(INotification).IsAssignableFrom(type); + } + + internal static string GetDisplayName(Type t) + { + var displayName = ObjectNames.NicifyVariableName(t.Name); + var attr = Attribute.GetCustomAttribute(t, typeof(DisplayNameAttribute), false) as DisplayNameAttribute; + if (attr != null) + displayName = attr.DisplayName; + return displayName; + } + + public static bool IsHiddenInMenu(Type type) + { + var attr = type.GetCustomAttributes(typeof(HideInMenuAttribute), false); + return attr.Length > 0; + } + + public struct ObjectReference + { + public Type type; + public bool isSceneReference; + } + + public static IEnumerable ObjectReferencesForType(Type type) + { + var objectReferences = ObjectReferenceField.FindObjectReferences(type); + var uniqueTypes = objectReferences.Select(objRef => objRef.type).Distinct(); + foreach (var refType in uniqueTypes) + { + var isSceneReference = objectReferences.Any(objRef => objRef.type == refType && objRef.isSceneReference); + yield return new ObjectReference { type = refType, isSceneReference = isSceneReference }; + } + } + + /// + /// Checks whether a type has an overridden method with a specific name. This method also checks overridden members in parent classes. + /// + public static bool HasOverrideMethod(System.Type t, string name) + { + const MethodAttributes mask = MethodAttributes.Virtual | MethodAttributes.NewSlot; + const MethodAttributes expectedResult = MethodAttributes.Virtual; + + var method = t.GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); + return method != null && (method.Attributes & mask) == expectedResult; + } + + /// + /// Returns whether the given type resides in the timeline assembly + /// + public static bool IsBuiltIn(System.Type t) + { + return t != null && t.Assembly.Equals(typeof(TimelineAsset).Assembly); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TypeUtility.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TypeUtility.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e73d4614ddc889b02e9b94a66804ed171af92db4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Utilities/TypeUtility.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4c1821c1816c6fa44967b8ecb79ea7e4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes.meta new file mode 100644 index 0000000000000000000000000000000000000000..db5962fb5d4947920c4d0477b6e86f743feca71d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 37472f5179ca2004489ac901814cdbc3 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimeReferenceMode.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimeReferenceMode.cs new file mode 100644 index 0000000000000000000000000000000000000000..873f7cdf3382199aa08792c238d61d44922ed05b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimeReferenceMode.cs @@ -0,0 +1,8 @@ +namespace UnityEditor.Timeline +{ + enum TimeReferenceMode + { + Local = 0, + Global = 1 + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimeReferenceMode.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimeReferenceMode.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..c6c0fc43076dac33e20c6ae29f96ed1592037629 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimeReferenceMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 34d6f60b171c1004e8335d52c65928a3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineActiveMode.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineActiveMode.cs new file mode 100644 index 0000000000000000000000000000000000000000..aa1dd5b523df5ee638386f1a5d20f21f0ba928ac --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineActiveMode.cs @@ -0,0 +1,42 @@ +namespace UnityEditor.Timeline +{ + class TimelineActiveMode : TimelineMode + { + public TimelineActiveMode() + { + headerState = new HeaderState + { + breadCrumb = TimelineModeGUIState.Enabled, + options = TimelineModeGUIState.Enabled, + sequenceSelector = TimelineModeGUIState.Enabled + }; + + trackOptionsState = new TrackOptionsState + { + newButton = TimelineModeGUIState.Enabled, + editAsAssetButton = TimelineModeGUIState.Hidden + }; + mode = TimelineModes.Active; + } + + public override bool ShouldShowTimeCursor(WindowState state) + { + return true; + } + + public override bool ShouldShowPlayRange(WindowState state) + { + return state.playRangeEnabled; + } + + public override TimelineModeGUIState ToolbarState(WindowState state) + { + return TimelineModeGUIState.Enabled; + } + + public override TimelineModeGUIState TrackState(WindowState state) + { + return TimelineModeGUIState.Enabled; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineActiveMode.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineActiveMode.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1d055ea8bc716434dfe37605e5179a493ffbd22a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineActiveMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 67ee43b2f6148de40861b289b0e00591 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineAssetEditionMode.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineAssetEditionMode.cs new file mode 100644 index 0000000000000000000000000000000000000000..06f8581293b09c15201c76a413f612aa2592c569 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineAssetEditionMode.cs @@ -0,0 +1,27 @@ +namespace UnityEditor.Timeline +{ + class TimelineAssetEditionMode : TimelineInactiveMode + { + public override TimelineModeGUIState TrackState(WindowState state) + { + return TimelineModeGUIState.Enabled; + } + + public TimelineAssetEditionMode() + { + headerState = new HeaderState + { + breadCrumb = TimelineModeGUIState.Enabled, + options = TimelineModeGUIState.Enabled, + sequenceSelector = TimelineModeGUIState.Enabled + }; + + trackOptionsState = new TrackOptionsState + { + newButton = TimelineModeGUIState.Enabled, + editAsAssetButton = TimelineModeGUIState.Enabled + }; + mode = TimelineModes.AssetEdition; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineAssetEditionMode.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineAssetEditionMode.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..6c5b2d1400f0cde695b431b93131980b48c8d98b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineAssetEditionMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3477d28057cb3e4469c7ea6b8dc23046 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineDisabledMode.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineDisabledMode.cs new file mode 100644 index 0000000000000000000000000000000000000000..dea7c1bdfe3e23339d373cfff3b996e97264ade6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineDisabledMode.cs @@ -0,0 +1,44 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class TimelineDisabledMode : TimelineMode + { + public TimelineDisabledMode() + { + headerState = new HeaderState + { + breadCrumb = TimelineModeGUIState.Enabled, + options = TimelineModeGUIState.Enabled, + sequenceSelector = TimelineModeGUIState.Enabled + }; + + trackOptionsState = new TrackOptionsState + { + newButton = TimelineModeGUIState.Enabled, + editAsAssetButton = TimelineModeGUIState.Enabled + }; + mode = TimelineModes.Disabled; + } + + public override bool ShouldShowPlayRange(WindowState state) + { + return false; + } + + public override bool ShouldShowTimeCursor(WindowState state) + { + return true; + } + + public override TimelineModeGUIState ToolbarState(WindowState state) + { + return TimelineModeGUIState.Disabled; + } + + public override TimelineModeGUIState TrackState(WindowState state) + { + return TimelineModeGUIState.Enabled; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineDisabledMode.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineDisabledMode.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..8139fb65d1de2e6466bce1a2774399f79d5ca2d9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineDisabledMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4c5eb52d37bb6714a98af73df7d9cf2c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineInactiveMode.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineInactiveMode.cs new file mode 100644 index 0000000000000000000000000000000000000000..bb630819234c8b9ab93f1eef3f622fe9a4cd9c5a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineInactiveMode.cs @@ -0,0 +1,47 @@ +namespace UnityEditor.Timeline +{ + class TimelineInactiveMode : TimelineMode + { + public TimelineInactiveMode() + { + headerState = new HeaderState + { + breadCrumb = TimelineModeGUIState.Disabled, + options = TimelineModeGUIState.Enabled, + sequenceSelector = TimelineModeGUIState.Enabled + }; + + trackOptionsState = new TrackOptionsState + { + newButton = TimelineModeGUIState.Disabled, + editAsAssetButton = TimelineModeGUIState.Enabled + }; + mode = TimelineModes.Inactive; + } + + public override bool ShouldShowPlayRange(WindowState state) + { + return false; + } + + public override bool ShouldShowTimeCursor(WindowState state) + { + return false; + } + + public override TimelineModeGUIState ToolbarState(WindowState state) + { + return TimelineModeGUIState.Disabled; + } + + public override TimelineModeGUIState TrackState(WindowState state) + { + return TimelineModeGUIState.Disabled; + } + + public override TimelineModeGUIState PreviewState(WindowState state) + { + return TimelineModeGUIState.Disabled; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineInactiveMode.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineInactiveMode.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..12a8898025efc6e0444270afcacd4829699e1393 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineInactiveMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5503f95d174761548a68a901beab13c2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineMode.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineMode.cs new file mode 100644 index 0000000000000000000000000000000000000000..7a578107bd6ba96699e3452c6e498dda4c378453 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineMode.cs @@ -0,0 +1,91 @@ +using System; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + enum TimelineModeGUIState + { + Disabled, + Hidden, + Enabled + } + + abstract class TimelineMode + { + public struct HeaderState + { + public TimelineModeGUIState breadCrumb; + public TimelineModeGUIState sequenceSelector; + public TimelineModeGUIState options; + } + + public struct TrackOptionsState + { + public TimelineModeGUIState newButton; + public TimelineModeGUIState editAsAssetButton; + } + + public HeaderState headerState { get; protected set; } + public TrackOptionsState trackOptionsState { get; protected set; } + public TimelineModes mode { get; protected set; } + + public abstract bool ShouldShowPlayRange(WindowState state); + public abstract bool ShouldShowTimeCursor(WindowState state); + + public virtual bool ShouldShowTrackBindings(WindowState state) + { + return ShouldShowTimeCursor(state); + } + + public virtual bool ShouldShowTimeArea(WindowState state) + { + return !state.IsEditingAnEmptyTimeline(); + } + + public abstract TimelineModeGUIState TrackState(WindowState state); + public abstract TimelineModeGUIState ToolbarState(WindowState state); + + public virtual TimelineModeGUIState PreviewState(WindowState state) + { + return state.ignorePreview ? TimelineModeGUIState.Disabled : TimelineModeGUIState.Enabled; + } + + public virtual TimelineModeGUIState EditModeButtonsState(WindowState state) + { + return TimelineModeGUIState.Enabled; + } + } + + /// + /// Different mode for Timeline + /// + [Flags] + public enum TimelineModes + { + /// + /// A playable director with a valid timeline is selected in editor. + /// + Active = 1, + /// + /// The timeline is not editable. (the TimelineAsset file is either readonly on disk or locked by source control). + /// + ReadOnly = 2, + /// + /// The timeline cannot be played or previewed. + /// + Inactive = 4, + /// + /// Disabled Timeline. + /// + Disabled = 8, + /// + /// Timeline in AssetEditing mode. + /// This mode is enabled when a timeline asset is selected in the project window. + /// + AssetEdition = 16, + /// + /// The timeline can be edited (either through playable director or selected timeline asset in project window). + /// + Default = Active | AssetEdition + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineMode.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineMode.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..7bf4435f110f23e316a1d11d25c2d53bb92fe97c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a2cb43d6b0c226443be7e176590837a5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineReadOnlyMode.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineReadOnlyMode.cs new file mode 100644 index 0000000000000000000000000000000000000000..21418cea2036729a6cf9c617f98859a8203ab325 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineReadOnlyMode.cs @@ -0,0 +1,52 @@ +namespace UnityEditor.Timeline +{ + class TimelineReadOnlyMode : TimelineMode + { + public TimelineReadOnlyMode() + { + headerState = new HeaderState() + { + breadCrumb = TimelineModeGUIState.Enabled, + options = TimelineModeGUIState.Enabled, + sequenceSelector = TimelineModeGUIState.Enabled, + }; + + trackOptionsState = new TrackOptionsState() + { + newButton = TimelineModeGUIState.Disabled, + editAsAssetButton = TimelineModeGUIState.Disabled, + }; + mode = TimelineModes.ReadOnly; + } + + public override bool ShouldShowPlayRange(WindowState state) + { + return state.editSequence.director != null && state.playRangeEnabled; + } + + public override bool ShouldShowTimeCursor(WindowState state) + { + return state.editSequence.director != null; + } + + public override TimelineModeGUIState TrackState(WindowState state) + { + return TimelineModeGUIState.Disabled; + } + + public override TimelineModeGUIState ToolbarState(WindowState state) + { + return state.editSequence.director == null ? TimelineModeGUIState.Disabled : TimelineModeGUIState.Enabled; + } + + public override TimelineModeGUIState PreviewState(WindowState state) + { + return state.editSequence.director == null ? TimelineModeGUIState.Disabled : TimelineModeGUIState.Enabled; + } + + public override TimelineModeGUIState EditModeButtonsState(WindowState state) + { + return TimelineModeGUIState.Disabled; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineReadOnlyMode.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineReadOnlyMode.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..bd04969ab03c1c6dc37624aa48d0b05de30caeb6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/Modes/TimelineReadOnlyMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3f8643c1f8dd449e85b548a14edbea2e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/PlaybackScroller.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/PlaybackScroller.cs new file mode 100644 index 0000000000000000000000000000000000000000..eca78c15c79bd9386c608c6b811bbacbb859814b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/PlaybackScroller.cs @@ -0,0 +1,67 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + /// + /// Scrolling mode during playback for the timeline window. + /// + public enum PlaybackScrollMode + { + /// + /// Timeline window doesn't change while the playhead is leaving the window. + /// + None, + /// + /// Timeline window pans its content when the playhead arrive at the right of the window (like a paging scrolling). + /// + Pan, + /// + /// Timeline window move the content as the playhead moves. + /// When the playhead reach the middle of the window, it stays there and the content scroll behind it. + /// + Smooth + } + + static class PlaybackScroller + { + public static void AutoScroll(WindowState state) + { + if (Event.current.type != EventType.Layout) + return; + + switch (state.autoScrollMode) + { + case PlaybackScrollMode.Pan: + DoPanScroll(state); + break; + case PlaybackScrollMode.Smooth: + DoSmoothScroll(state); + break; + } + } + + static void DoSmoothScroll(WindowState state) + { + if (state.playing) + state.SetPlayHeadToMiddle(); + + state.UpdateLastFrameTime(); + } + + static void DoPanScroll(WindowState state) + { + if (!state.playing) + return; + + var paddingDeltaTime = state.PixelDeltaToDeltaTime(WindowConstants.autoPanPaddingInPixels); + var showRange = state.timeAreaShownRange; + var rightBoundForPan = showRange.y - paddingDeltaTime; + if (state.editSequence.time > rightBoundForPan) + { + var leftBoundForPan = showRange.x + paddingDeltaTime; + var delta = rightBoundForPan - leftBoundForPan; + state.SetTimeAreaShownRange(showRange.x + delta, showRange.y + delta); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/PlaybackScroller.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/PlaybackScroller.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..70842a743bb02ad3c9b99f75f6ce26515b67e874 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/PlaybackScroller.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 98545765d7a2b614b921715928035ee2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineMarkerHeaderGUI.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineMarkerHeaderGUI.cs new file mode 100644 index 0000000000000000000000000000000000000000..58315195a0f94d621c509e4d9330a0a109f1883e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineMarkerHeaderGUI.cs @@ -0,0 +1,194 @@ +using System; +using System.Linq; +using UnityEditor.Timeline.Actions; +using UnityEngine; +using UnityEngine.Timeline; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class TimelineMarkerHeaderGUI : IRowGUI, ILayerable + { + int m_TrackHash; + TimelineAsset timeline { get; } + WindowState state { get; } + MarkersLayer m_Layer; + LayerZOrder m_ZOrder = new LayerZOrder(Layer.MarkerHeaderTrack, 0); + + struct DrawData + { + public Rect headerRect; + public Rect contentRect; + public GUIStyle trackHeaderFont; + public Color colorTrackFont; + public bool showLockButton; + public bool showMuteButton; + } + + public TimelineMarkerHeaderGUI(TimelineAsset asset, WindowState state) + { + m_TrackHash = -1; + timeline = asset; + this.state = state; + } + + public TrackAsset asset { get { return timeline.markerTrack; } } + public Rect boundingRect { get; private set; } + public bool locked { get { return !state.showMarkerHeader; } } + + public bool showMarkers + { + get { return state.showMarkerHeader; } + } + + public bool muted + { + get { return timeline.markerTrack != null && timeline.markerTrack.muted; } + } + + Rect IRowGUI.ToWindowSpace(Rect rect) + { + //header gui is already in global coordinates + return rect; + } + + public void Draw(Rect markerHeaderRect, Rect markerContentRect, WindowState state) + { + boundingRect = markerContentRect; + var data = new DrawData() + { + headerRect = markerHeaderRect, + contentRect = markerContentRect, + trackHeaderFont = DirectorStyles.Instance.trackHeaderFont, + colorTrackFont = DirectorStyles.Instance.customSkin.colorTrackFont, + showLockButton = locked, + showMuteButton = muted + }; + + if (state.showMarkerHeader) + { + DrawMarkerDrawer(data, state); + if (Event.current.type == EventType.Repaint) + state.spacePartitioner.AddBounds(this, boundingRect); + } + + if (asset != null && Hash() != m_TrackHash) + Rebuild(); + + var rect = state.showMarkerHeader ? markerContentRect : state.timeAreaRect; + using (new GUIViewportScope(rect)) + { + if (m_Layer != null) + m_Layer.Draw(rect, state); + + HandleDragAndDrop(); + } + } + + public void Rebuild() + { + if (asset == null) + return; + + m_Layer = new MarkersLayer(Layer.MarkersOnHeader, this); + m_TrackHash = Hash(); + } + + void HandleDragAndDrop() + { + if (TimelineWindow.instance.state.editSequence.isReadOnly) + return; + + if (Event.current == null || Event.current.type != EventType.DragUpdated && + Event.current.type != EventType.DragPerform && Event.current.type != EventType.DragExited) + return; + + timeline.CreateMarkerTrack(); // Ensure Marker track is created. + var objectsBeingDropped = DragAndDrop.objectReferences.OfType(); + var candidateTime = TimelineHelpers.GetCandidateTime(Event.current.mousePosition); + var perform = Event.current.type == EventType.DragPerform; + var director = state.editSequence != null ? state.editSequence.director : null; + DragAndDrop.visualMode = TimelineDragging.HandleClipPaneObjectDragAndDrop(objectsBeingDropped, timeline.markerTrack, perform, + timeline, null, director, candidateTime, TimelineDragging.ResolveType); + if (perform && DragAndDrop.visualMode == DragAndDropVisualMode.Copy) + { + DragAndDrop.AcceptDrag(); + } + } + + int Hash() + { + return timeline.markerTrack == null ? 0 : timeline.markerTrack.Hash(); + } + + static void DrawMarkerDrawer(DrawData data, WindowState state) + { + DrawMarkerDrawerHeaderBackground(data); + DrawMarkerDrawerHeader(data, state); + DrawMarkerDrawerContentBackground(data); + } + + static void DrawMarkerDrawerHeaderBackground(DrawData data) + { + var backgroundColor = DirectorStyles.Instance.customSkin.markerHeaderDrawerBackgroundColor; + var bgRect = data.headerRect; + EditorGUI.DrawRect(bgRect, backgroundColor); + } + + static void DrawMarkerDrawerHeader(DrawData data, WindowState state) + { + var textStyle = data.trackHeaderFont; + textStyle.normal.textColor = data.colorTrackFont; + var labelRect = data.headerRect; + labelRect.x += DirectorStyles.kBaseIndent; + + EditorGUI.LabelField(labelRect, DirectorStyles.timelineMarkerTrackHeader); + + const float buttonSize = WindowConstants.trackHeaderButtonSize; + const float padding = WindowConstants.trackHeaderButtonPadding; + var x = data.headerRect.xMax - buttonSize - padding - 2f; + var y = data.headerRect.y + (data.headerRect.height - buttonSize) / 2.0f; + var buttonRect = new Rect(x, y, buttonSize, buttonSize); + + DrawTrackDropDownMenu(buttonRect, state); + buttonRect.x -= 16.0f; + + if (data.showMuteButton) + { + DrawMuteButton(buttonRect); + buttonRect.x -= 16.0f; + } + + if (data.showLockButton) + { + DrawLockButton(buttonRect); + } + } + + static void DrawMarkerDrawerContentBackground(DrawData data) + { + var trackBackgroundColor = DirectorStyles.Instance.customSkin.markerDrawerBackgroundColor; + EditorGUI.DrawRect(data.contentRect, trackBackgroundColor); + } + + static void DrawLockButton(Rect rect) + { + if (GUI.Button(rect, GUIContent.none, TimelineWindow.styles.trackLockButton)) + Invoker.InvokeWithSelected(); + } + + static void DrawTrackDropDownMenu(Rect rect, WindowState state) + { + if (GUI.Button(rect, GUIContent.none, DirectorStyles.Instance.trackOptions)) + SequencerContextMenu.ShowMarkerHeaderContextMenu(null, state); + } + + static void DrawMuteButton(Rect rect) + { + if (GUI.Button(rect, GUIContent.none, TimelineWindow.styles.markerHeaderMuteButton)) + Invoker.InvokeWithSelected(); + } + + public LayerZOrder zOrder => m_ZOrder; + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineMarkerHeaderGUI.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineMarkerHeaderGUI.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..eefe711767113d417dbacf599c4908ef7fdd0318 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineMarkerHeaderGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4068e97704a16794ea218ba560cdc1e9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow.cs new file mode 100644 index 0000000000000000000000000000000000000000..2eb3d774e820503fffc443b20a706cd0e1d724b1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow.cs @@ -0,0 +1,519 @@ +using System; +using System.Collections.Generic; +using UnityEditor.Callbacks; +using UnityEngine; +using UnityEngine.Events; +using UnityEngine.Playables; +using UnityEngine.SceneManagement; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [EditorWindowTitle(title = "Timeline", useTypeNameAsIconName = true)] + partial class TimelineWindow : EditorWindow, IHasCustomMenu + { + [Serializable] + public class TimelineWindowPreferences + { + public bool playRangeLoopMode = true; + public EditMode.EditType editType = EditMode.EditType.Mix; + public TimeReferenceMode timeReferenceMode = TimeReferenceMode.Local; + } + + [SerializeField] TimelineWindowPreferences m_Preferences = new TimelineWindowPreferences(); + public TimelineWindowPreferences preferences { get { return m_Preferences; } } + + [SerializeField] + EditorGUIUtility.EditorLockTracker m_LockTracker = new EditorGUIUtility.EditorLockTracker(); + + readonly PreviewResizer m_PreviewResizer = new PreviewResizer(); + bool m_LastFrameHadSequence; + bool m_ForceRefreshLastSelection; + int m_CurrentSceneHashCode = -1; + + [NonSerialized] + bool m_HasBeenInitialized; + + [SerializeField] + SequenceHierarchy m_SequenceHierarchy; + static SequenceHierarchy s_LastHierarchy; + + public static TimelineWindow instance { get; private set; } + public Rect clientArea { get; set; } + public bool isDragging { get; set; } + public static DirectorStyles styles { get { return DirectorStyles.Instance; } } + public List allTracks + { + get + { + return treeView != null ? treeView.allTrackGuis : new List(); + } + } + + public WindowState state { get; private set; } + + public bool locked + { + get + { + // we can never be in a locked state if there is no timeline asset + if (state.editSequence.asset == null) + return false; + + return m_LockTracker.isLocked; + } + set { m_LockTracker.isLocked = value; } + } + + public bool hierarchyChangedThisFrame { get; private set; } + + public TimelineWindow() + { + InitializeManipulators(); + m_LockTracker.lockStateChanged.AddPersistentListener(OnLockStateChanged, UnityEventCallState.EditorAndRuntime); + } + + void OnLockStateChanged(bool locked) + { + // Make sure that upon unlocking, any selection change is updated + // Case 1123119 -- only force rebuild if not recording + if (!locked) + RefreshSelection(state != null && !state.recording); + } + + void OnEnable() + { + if (m_SequencePath == null) + m_SequencePath = new SequencePath(); + + if (m_SequenceHierarchy == null) + { + // The sequence hierarchy will become null if maximize on play is used for in/out of playmode + // a static var will hang on to the reference + if (s_LastHierarchy != null) + m_SequenceHierarchy = s_LastHierarchy; + else + m_SequenceHierarchy = SequenceHierarchy.CreateInstance(); + + state = null; + } + s_LastHierarchy = m_SequenceHierarchy; + + titleContent = GetLocalizedTitleContent(); + + m_PreviewResizer.Init("TimelineWindow"); + + // Unmaximize fix : when unmaximizing, a new window is enabled and disabled. Prevent it from overriding the instance pointer. + if (instance == null) + instance = this; + + AnimationClipCurveCache.Instance.OnEnable(); + TrackAsset.OnClipPlayableCreate += m_PlayableLookup.UpdatePlayableLookup; + TrackAsset.OnTrackAnimationPlayableCreate += m_PlayableLookup.UpdatePlayableLookup; + + if (state == null) + { + state = new WindowState(this, s_LastHierarchy); + Initialize(); + RefreshSelection(true); + m_ForceRefreshLastSelection = true; + } + } + + void OnDisable() + { + if (instance == this) + instance = null; + + if (state != null) + state.Reset(); + + if (instance == null) + SelectionManager.RemoveTimelineSelection(); + + AnimationClipCurveCache.Instance.OnDisable(); + TrackAsset.OnClipPlayableCreate -= m_PlayableLookup.UpdatePlayableLookup; + TrackAsset.OnTrackAnimationPlayableCreate -= m_PlayableLookup.UpdatePlayableLookup; + TimelineWindowViewPrefs.SaveAll(); + TimelineWindowViewPrefs.UnloadAllViewModels(); + } + + void OnDestroy() + { + if (state != null) + { + state.OnDestroy(); + } + m_HasBeenInitialized = false; + RemoveEditorCallbacks(); + AnimationClipCurveCache.Instance.Clear(); + TimelineAnimationUtilities.UnlinkAnimationWindow(); + } + + void OnLostFocus() + { + isDragging = false; + + if (state != null) + state.captured.Clear(); + + Repaint(); + } + + void OnFocus() + { + if (state == null) return; + + if (lastSelectedGO != Selection.activeObject) + { + // selection may have changed while Timeline Editor was looking away + RefreshSelection(false); + } + } + + void OnHierarchyChange() + { + hierarchyChangedThisFrame = true; + Repaint(); + } + + void OnStateChange() + { + state.UpdateRecordingState(); + if (treeView != null && state.editSequence.asset != null) + treeView.Reload(); + if (m_MarkerHeaderGUI != null) + m_MarkerHeaderGUI.Rebuild(); + } + + void OnGUI() + { + InitializeGUIIfRequired(); + UpdateGUIConstants(); + UpdateViewStateHash(); + + EditMode.HandleModeClutch(); // TODO We Want that here? + + DetectStylesChange(); + DetectActiveSceneChanges(); + DetectStateChanges(); + + state.ProcessStartFramePendingUpdates(); + + var clipRect = new Rect(0.0f, 0.0f, position.width, position.height); + + using (new GUIViewportScope(clipRect)) + state.InvokeWindowOnGuiStarted(Event.current); + + if (Event.current.type == EventType.MouseDrag && state != null && state.mouseDragLag > 0.0f) + { + state.mouseDragLag -= Time.deltaTime; + return; + } + + if (PerformUndo()) + return; + + if (state != null && state.ignorePreview && state.playing) + { + if (state.recording) + state.recording = false; + Repaint(); + } + + clientArea = position; + + PlaybackScroller.AutoScroll(state); + DoLayout(); + + // overlays + if (state.captured.Count > 0) + { + using (new GUIViewportScope(clipRect)) + { + foreach (var o in state.captured) + { + o.Overlay(Event.current, state); + } + Repaint(); + } + } + + if (state.showQuadTree) + { + var fillColor = new Color(1.0f, 1.0f, 1.0f, 0.1f); + state.spacePartitioner.DebugDraw(fillColor, Color.yellow); + state.headerSpacePartitioner.DebugDraw(fillColor, Color.green); + } + + // attempt another rebuild -- this will avoid 1 frame flashes + if (Event.current.type == EventType.Repaint) + { + RebuildGraphIfNecessary(); + state.ProcessEndFramePendingUpdates(); + } + + using (new GUIViewportScope(clipRect)) + { + if (Event.current.type == EventType.Repaint) + EditMode.inputHandler.OnGUI(state, Event.current); + } + + if (Event.current.type == EventType.Repaint) + hierarchyChangedThisFrame = false; + } + + static void DetectStylesChange() + { + DirectorStyles.ReloadStylesIfNeeded(); + } + + void DetectActiveSceneChanges() + { + if (m_CurrentSceneHashCode == -1) + { + m_CurrentSceneHashCode = SceneManager.GetActiveScene().GetHashCode(); + } + + if (m_CurrentSceneHashCode != SceneManager.GetActiveScene().GetHashCode()) + { + bool isSceneStillLoaded = false; + for (int a = 0; a < SceneManager.sceneCount; a++) + { + var scene = SceneManager.GetSceneAt(a); + if (scene.GetHashCode() == m_CurrentSceneHashCode && scene.isLoaded) + { + isSceneStillLoaded = true; + break; + } + } + + if (!isSceneStillLoaded) + { + if (!locked) + ClearCurrentTimeline(); + m_CurrentSceneHashCode = SceneManager.GetActiveScene().GetHashCode(); + } + } + } + + void DetectStateChanges() + { + if (state != null) + { + state.editSequence.ResetIsReadOnly(); //Force reset readonly for asset flag for each frame. + // detect if the sequence was removed under our feet + if (m_LastFrameHadSequence && state.editSequence.asset == null) + { + ClearCurrentTimeline(); + } + m_LastFrameHadSequence = state.editSequence.asset != null; + + // the currentDirector can get set to null by a deletion or scene unloading so polling is required + if (state.editSequence.director == null) + { + state.recording = false; + state.previewMode = false; + + if (!locked && m_LastFrameHadSequence) + { + // the user may be adding a new PlayableDirector to a selected GameObject, make sure the timeline editor is shows the proper director if none is already showing + var selectedGameObject = Selection.activeObject != null ? Selection.activeObject as GameObject : null; + var selectedDirector = selectedGameObject != null ? selectedGameObject.GetComponent() : null; + if (selectedDirector != null) + { + SetCurrentTimeline(selectedDirector); + } + } + } + else + { + // the user may have changed the timeline associated with the current director + if (state.editSequence.asset != state.editSequence.director.playableAsset) + { + if (!locked) + { + SetCurrentTimeline(state.editSequence.director); + } + else + { + // Keep locked on the current timeline but set the current director to null since it's not the timeline owner anymore + SetCurrentTimeline(state.editSequence.asset); + } + } + } + } + } + + void Initialize() + { + if (!m_HasBeenInitialized) + { + InitializeStateChange(); + InitializeEditorCallbacks(); + m_HasBeenInitialized = true; + } + } + + void RefreshLastSelectionIfRequired() + { + // case 1088918 - workaround for the instanceID to object cache being update during Awake. + // This corrects any playableDirector ptrs with the correct cached version + // This can happen when going from edit to playmode + if (m_ForceRefreshLastSelection) + { + m_ForceRefreshLastSelection = false; + RestoreLastSelection(true); + } + } + + void InitializeGUIIfRequired() + { + RefreshLastSelectionIfRequired(); + InitializeTimeArea(); + if (treeView == null && state.editSequence.asset != null) + { + treeView = new TimelineTreeViewGUI(this, state.editSequence.asset, position); + } + } + + void UpdateGUIConstants() + { + m_HorizontalScrollBarSize = + GUI.skin.horizontalScrollbar.fixedHeight + GUI.skin.horizontalScrollbar.margin.top; + m_VerticalScrollBarSize = (treeView != null && treeView.showingVerticalScrollBar) + ? GUI.skin.verticalScrollbar.fixedWidth + GUI.skin.verticalScrollbar.margin.left + : 0; + } + + void UpdateViewStateHash() + { + if (Event.current.type == EventType.Layout) + state.UpdateViewStateHash(); + } + + static bool PerformUndo() + { + if (!Event.current.isKey) + return false; + + if (Event.current.keyCode != KeyCode.Z) + return false; + + if (!EditorGUI.actionKey) + return false; + + return true; + } + + public void RebuildGraphIfNecessary(bool evaluate = true) + { + if (state == null || state.editSequence.director == null || state.editSequence.asset == null) + return; + + if (state.rebuildGraph) + { + // rebuilding the graph resets the time + double time = state.editSequence.time; + + var wasPlaying = false; + + // disable preview mode, + if (!state.ignorePreview) + { + wasPlaying = state.playing; + + state.previewMode = false; + state.GatherProperties(state.masterSequence.director); + } + state.RebuildPlayableGraph(); + state.editSequence.time = time; + + if (wasPlaying) + state.Play(); + + if (evaluate) + { + // put the scene back in the correct state + state.EvaluateImmediate(); + + // this is necessary to see accurate results when inspector refreshes + // case 1154802 - this will property re-force time on the director, so + // the play head won't snap back to the timeline duration on rebuilds + if (!state.playing) + state.Evaluate(); + } + Repaint(); + } + + state.rebuildGraph = false; + } + + // for tests + public new void RepaintImmediately() + { + base.RepaintImmediately(); + } + + internal static bool IsEditingTimelineAsset(TimelineAsset timelineAsset) + { + return instance != null && instance.state != null && instance.state.editSequence.asset == timelineAsset; + } + + internal static void RepaintIfEditingTimelineAsset(TimelineAsset timelineAsset) + { + if (IsEditingTimelineAsset(timelineAsset)) + instance.Repaint(); + } + + internal class DoCreateTimeline : ProjectWindowCallback.EndNameEditAction + { + public override void Action(int instanceId, string pathName, string resourceFile) + { + var timeline = TimelineUtility.CreateAndSaveTimelineAsset(pathName); + ProjectWindowUtil.ShowCreatedAsset(timeline); + } + } + + [MenuItem("Assets/Create/Timeline", false, 450)] + public static void CreateNewTimeline() + { + var icon = EditorGUIUtility.IconContent("TimelineAsset Icon").image as Texture2D; + ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance(), "New Timeline.playable", icon, null); + } + + [MenuItem("Window/Sequencing/Timeline", false, 1)] + public static void ShowWindow() + { + GetWindow(typeof(SceneView)); + instance.Focus(); + } + + [OnOpenAsset(1)] + public static bool OnDoubleClick(int instanceID, int line) + { + var assetDoubleClicked = EditorUtility.InstanceIDToObject(instanceID) as TimelineAsset; + if (assetDoubleClicked == null) + return false; + + ShowWindow(); + instance.SetCurrentTimeline(assetDoubleClicked); + + return true; + } + + public virtual void AddItemsToMenu(GenericMenu menu) + { + bool disabled = state == null || state.editSequence.asset == null; + + m_LockTracker.AddItemsToMenu(menu, disabled); + } + + protected virtual void ShowButton(Rect r) + { + bool disabled = state == null || state.editSequence.asset == null; + + m_LockTracker.ShowButton(r, DirectorStyles.Instance.timelineLockButton, disabled); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5d0992be9298f93bad9cdbf548eb351205c03bfb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f817a38900380be47942905e17e7d39b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindowTimeControl.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindowTimeControl.cs new file mode 100644 index 0000000000000000000000000000000000000000..c69f972c3a7a27672abf26f3349150f387945be1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindowTimeControl.cs @@ -0,0 +1,314 @@ +using System; +using UnityEditorInternal; +using UnityEngine; +using UnityEngine.Timeline; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class TimelineWindowTimeControl : IAnimationWindowControl + { + [Serializable] + public struct ClipData + { + public double start; + public double duration; + public TrackAsset track; + } + + [SerializeField] ClipData m_ClipData; + [SerializeField] TimelineClip m_Clip; + [SerializeField] AnimationWindowState m_AnimWindowState; + + TrackAsset track + { + get + { + if (m_Clip != null) + { + return m_Clip.parentTrack; + } + return m_ClipData.track; + } + } + + static TimelineWindow window + { + get + { + return TimelineWindow.instance; + } + } + + static WindowState state + { + get + { + if (window != null) + return window.state; + return null; + } + } + + void OnStateChange() + { + if (state != null && state.dirtyStamp > 0 && m_AnimWindowState != null) + m_AnimWindowState.Repaint(); + } + + public void Init(AnimationWindowState animState, TimelineClip clip) + { + m_Clip = clip; + m_AnimWindowState = animState; + } + + public void Init(AnimationWindowState animState, ClipData clip) + { + m_ClipData = clip; + m_AnimWindowState = animState; + } + + public override void OnEnable() + { + if (state != null) + state.OnTimeChange += OnStateChange; + + base.OnEnable(); + } + + public void OnDisable() + { + if (state != null) + state.OnTimeChange -= OnStateChange; + } + + public override AnimationKeyTime time + { + get + { + if (state == null) + return AnimationKeyTime.Time(0.0f, 0.0f); + + return AnimationKeyTime.Time(ToAnimationClipTime(state.editSequence.time), state.referenceSequence.frameRate); + } + } + + void ChangeTime(float newTime) + { + if (state != null && state.editSequence.director != null) + { + // avoid rounding errors + var finalTime = ToGlobalTime(newTime); + if (TimeUtility.OnFrameBoundary(finalTime, state.referenceSequence.frameRate, TimeUtility.kFrameRateEpsilon)) + finalTime = TimeUtility.RoundToFrame(finalTime, state.referenceSequence.frameRate); + state.editSequence.time = finalTime; + + window.Repaint(); + } + } + + static void ChangeFrame(int frame) + { + if (state != null) + { + state.editSequence.frame = frame; + window.Repaint(); + } + } + + public override void GoToTime(float newTime) + { + ChangeTime(newTime); + } + + public override void GoToFrame(int frame) + { + ChangeFrame(frame); + } + + public override void StartScrubTime() {} + + public override void EndScrubTime() {} + + public override void ScrubTime(float newTime) + { + ChangeTime(newTime); + } + + public override void GoToPreviousFrame() + { + if (state != null) + ChangeFrame(state.editSequence.frame - 1); + } + + public override void GoToNextFrame() + { + if (state != null) + ChangeFrame(state.editSequence.frame + 1); + } + + AnimationWindowCurve[] GetCurves() + { + var curves = + (m_AnimWindowState.showCurveEditor && + m_AnimWindowState.activeCurves.Count > 0) ? m_AnimWindowState.activeCurves : m_AnimWindowState.allCurves; + return curves.ToArray(); + } + + public override void GoToPreviousKeyframe() + { + var newTime = AnimationWindowUtility.GetPreviousKeyframeTime(GetCurves(), time.time, m_AnimWindowState.clipFrameRate); + GoToTime(m_AnimWindowState.SnapToFrame(newTime, AnimationWindowState.SnapMode.SnapToClipFrame)); + } + + public override void GoToNextKeyframe() + { + var newTime = AnimationWindowUtility.GetNextKeyframeTime(GetCurves(), time.time, m_AnimWindowState.clipFrameRate); + GoToTime(m_AnimWindowState.SnapToFrame(newTime, AnimationWindowState.SnapMode.SnapToClipFrame)); + } + + public override void GoToFirstKeyframe() + { + GoToTime(0); + } + + public override void GoToLastKeyframe() + { + double animClipTime = 0; + if (m_Clip != null) + { + var curves = m_Clip.curves; + var animAsset = m_Clip.asset as AnimationPlayableAsset; + if (animAsset != null) + { + animClipTime = animAsset.clip != null ? animAsset.clip.length : 0; + } + else if (curves != null) + { + animClipTime = curves.length; + } + else + { + animClipTime = m_Clip.clipAssetDuration; + } + } + else + { + animClipTime = m_ClipData.duration; + } + + GoToTime((float)animClipTime); + } + + public override bool canPlay + { + get + { + return state != null && state.previewMode; + } + } + + public override bool playing + { + get + { + return state != null && state.playing; + } + } + + static void SetPlaybackState(bool playbackState) + { + if (state == null || playbackState == state.playing) + return; + + state.SetPlaying(playbackState); + } + + public override bool StartPlayback() + { + SetPlaybackState(true); + return state != null && state.playing; + } + + public override void StopPlayback() + { + SetPlaybackState(false); + } + + public override bool PlaybackUpdate() { return state != null && state.playing; } + + public override bool canRecord + { + get { return state != null && state.canRecord; } + } + + public override bool recording + { + get { return state != null && state.recording; } + } + + public override bool canPreview + { + get { return false; } + } + + public override bool previewing + { + get { return false; } + } + + public override bool StartRecording(Object targetObject) + { + if (!canRecord) + return false; + + if (track != null && state != null && !state.ignorePreview) + { + state.ArmForRecord(track); + return state.recording; + } + + return false; + } + + public override void StopRecording() + { + if (track != null && state != null && !state.ignorePreview) + state.UnarmForRecord(track); + } + + public override void OnSelectionChanged() {} + + public override void ResampleAnimation() {} + + public override bool StartPreview() + { + if (state != null) + state.previewMode = true; + return state != null && state.previewMode; + } + + public override void StopPreview() + { + if (state != null) + state.previewMode = false; + } + + public override void ProcessCandidates() {} + public override void ClearCandidates() {} + + double ToGlobalTime(float localTime) + { + if (m_Clip != null) + return Math.Max(0, m_Clip.FromLocalTimeUnbound(localTime)); + return Math.Max(0, m_ClipData.start + localTime); + } + + float ToAnimationClipTime(double globalTime) + { + if (m_Clip != null) + return (float)m_Clip.ToLocalTimeUnbound(globalTime); + return (float)(globalTime - m_ClipData.start); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindowTimeControl.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindowTimeControl.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..6d8fd714f0ea1d1828217cbd18b410f9c2110397 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindowTimeControl.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6f25fb081e85cb743b272c2f7fbc2f6b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_ActiveTimeline.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_ActiveTimeline.cs new file mode 100644 index 0000000000000000000000000000000000000000..004209fea63aab54cf3b31ef45548dee0b6f07af --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_ActiveTimeline.cs @@ -0,0 +1,80 @@ +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + private TimelineAsset m_PreviousMasterSequence; + + public void ClearCurrentTimeline() + { + SetCurrentTimeline(null, null, null, true); + } + + public void SetCurrentTimeline(TimelineAsset seq) + { + SetCurrentTimeline(seq, null, null); + } + + public void SetCurrentTimeline(PlayableDirector director, TimelineClip hostClip = null) + { + var asset = director != null ? director.playableAsset as TimelineAsset : null; + SetCurrentTimeline(asset, director, hostClip); + } + + void SetCurrentTimeline(TimelineAsset seq, PlayableDirector instanceOfDirector, TimelineClip hostClip, bool force = false) + { + if (state == null) + return; + + if (!force && + state.editSequence.hostClip == hostClip && + state.editSequence.director == instanceOfDirector && + state.editSequence.asset == seq) + return; + + state.SetCurrentSequence(seq, instanceOfDirector, hostClip); + } + + void OnBeforeSequenceChange() + { + treeView = null; + m_MarkerHeaderGUI = null; + m_TimeAreaDirty = true; + + state.Reset(); + m_PlayableLookup.ClearPlayableLookup(); + + // clear old editors to caches, like audio previews, get flushed + CustomTimelineEditorCache.ClearCache(); + CustomTimelineEditorCache.ClearCache(); + CustomTimelineEditorCache.ClearCache(); + + m_PreviousMasterSequence = state.masterSequence.asset; + } + + 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) + { + AnimationClipCurveCache.Instance.Clear(); + TimelineAnimationUtilities.UnlinkAnimationWindow(); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_ActiveTimeline.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_ActiveTimeline.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..0b1212277781498380cf9bbac6d995921eb613eb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_ActiveTimeline.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b7abcd1a72bb7174ca58e813c6eee9c2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Breadcrumbs.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Breadcrumbs.cs new file mode 100644 index 0000000000000000000000000000000000000000..9cb9502ed5be9db0dbc48e6893fe2f450948a432 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Breadcrumbs.cs @@ -0,0 +1,119 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + List m_BreadCrumbLabels = new List(100); + + static TitleMode GetTitleMode(ISequenceState sequence) + { + var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetCurrentPrefabStage(); + // Top level + if (sequence.hostClip == null) + { + if (sequence.director != null && prefabStage != null && prefabStage.IsPartOfPrefabContents(sequence.director.gameObject)) + return TitleMode.Prefab; + if (sequence.director != null && PrefabUtility.IsPartOfPrefabAsset(sequence.director)) + return TitleMode.PrefabOutOfContext; + if (sequence.director != null && !sequence.director.isActiveAndEnabled) + return TitleMode.DisabledComponent; + if (sequence.director != null) + return TitleMode.GameObject; + if (sequence.asset != null) + return TitleMode.Asset; + } + // Subtimelines only get an error icon + else if (sequence.director != null && !sequence.director.isActiveAndEnabled && !PrefabUtility.IsPartOfPrefabAsset(sequence.director)) + return TitleMode.DisabledComponent; + + return TitleMode.None; + } + + void DrawBreadcrumbs() + { + if (state == null) + return; + var count = 0; + foreach (var sequence in state.GetAllSequences()) + { + var title = new BreadCrumbTitle + { + name = DisplayNameHelper.GetDisplayName(sequence), + mode = GetTitleMode(sequence) + }; + if (count >= m_BreadCrumbLabels.Count) + m_BreadCrumbLabels.Add(title); + else + m_BreadCrumbLabels[count] = title; + count++; + } + + if (m_BreadCrumbLabels.Count > count) + m_BreadCrumbLabels.RemoveRange(count, m_BreadCrumbLabels.Count - count); + + using (new EditorGUI.DisabledScope(currentMode.headerState.breadCrumb == TimelineModeGUIState.Disabled)) + { + var width = position.width - WindowConstants.playControlsWidth - WindowConstants.cogButtonWidth; + BreadcrumbDrawer.Draw(width, m_BreadCrumbLabels, NavigateToBreadcrumbIndex); + } + } + + void NavigateToBreadcrumbIndex(int index) + { + state.PopSequencesUntilCount(index + 1); + } + + void DrawSequenceSelector() + { + using (new EditorGUI.DisabledScope(currentMode.headerState.sequenceSelector == TimelineModeGUIState.Disabled)) + { + if (EditorGUILayout.DropdownButton(DirectorStyles.timelineSelectorArrow, FocusType.Passive, DirectorStyles.Instance.sequenceSwitcher, GUILayout.Width(WindowConstants.selectorWidth))) + ShowSequenceSelector(); + } + } + + void ShowSequenceSelector() + { + var allDirectors = TimelineUtility.GetDirectorsInSceneUsingAsset(null); + + var formatter = new SequenceMenuNameFormater(); + var namesAndDirectors = new List>(); + foreach (var d in allDirectors) + { + if (d.playableAsset is TimelineAsset) + { + var text = formatter.Format(DisplayNameHelper.GetDisplayName(d)); + namesAndDirectors.Add(new ValueTuple(text, d)); + } + } + + var sequenceMenu = new GenericMenu(); + foreach (var(timelineName, playableDirector) in namesAndDirectors.OrderBy(i => i.Item1)) + { + var isCurrent = state.masterSequence.director == playableDirector; + sequenceMenu.AddItem(new GUIContent(timelineName), isCurrent, OnSequenceSelected, playableDirector); + } + + if (allDirectors.Length == 0) + sequenceMenu.AddDisabledItem(DirectorStyles.noTimelinesInScene); + + sequenceMenu.DropDown(EditorGUILayout.s_LastRect); + } + + void OnSequenceSelected(object arg) + { + var directorToBindTo = (PlayableDirector)arg; + if (directorToBindTo) + { + // don't just select the object, it may already be selected. + SetCurrentTimeline(directorToBindTo); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Breadcrumbs.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Breadcrumbs.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2746400799cc72d2fb5cce0e18103dfee8d9581d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Breadcrumbs.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e2cd16a2d73fe7a4c9affa2b790eb5e0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Duration.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Duration.cs new file mode 100644 index 0000000000000000000000000000000000000000..63b28e9208e52aa45225156b1ec526b1a76455b2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Duration.cs @@ -0,0 +1,128 @@ +using System; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + TimeAreaItem m_TimelineDuration; + + void DurationGUI(TimelineItemArea area, double duration) + { + // don't show the duration if the time area is not visible for some other reason. + if (!currentMode.ShouldShowTimeArea(state)) + return; + + bool headerMode = area == TimelineItemArea.Header; + + if (state.IsEditingASubTimeline()) + { + if (headerMode) + HighlightTimeAreaRange(state.editSequence.GetEvaluableRange(), DirectorStyles.Instance.customSkin.colorSubSequenceDurationLine); + + return; + } + + // don't show the duration if there's none. + if (state.editSequence.asset.durationMode == TimelineAsset.DurationMode.BasedOnClips && duration <= 0.0f) + return; + + if (m_TimelineDuration == null || m_TimelineDuration.style != styles.endmarker) + { + m_TimelineDuration = new TimeAreaItem(styles.endmarker, OnTrackDurationDrag) + { + tooltip = "End of sequence marker", + boundOffset = new Vector2(0.0f, -DirectorStyles.kDurationGuiThickness) + }; + } + + DrawDuration(headerMode, !headerMode, duration); + } + + void DrawDuration(bool drawhead, bool drawline, double duration) + { + if (state.TimeIsInRange((float)duration)) + { + // Set the colors based on the mode + Color lineColor = DirectorStyles.Instance.customSkin.colorEndmarker; + Color headColor = Color.white; + + bool canMoveHead = !EditorApplication.isPlaying && state.editSequence.asset.durationMode == TimelineAsset.DurationMode.FixedLength; + + if (canMoveHead) + { + if (Event.current.type == EventType.MouseDown) + { + if (m_TimelineDuration.bounds.Contains(Event.current.mousePosition)) + { + if (m_PlayHead != null && m_PlayHead.bounds.Contains(Event.current.mousePosition)) + { + // ignore duration markers if the mouse is over the TimeCursor. + canMoveHead = false; + } + } + } + } + else + { + lineColor.a *= 0.66f; + headColor = DirectorStyles.Instance.customSkin.colorDuration; + } + + if (canMoveHead) + m_TimelineDuration.HandleManipulatorsEvents(state); + + m_TimelineDuration.lineColor = lineColor; + m_TimelineDuration.headColor = headColor; + m_TimelineDuration.drawHead = drawhead; + m_TimelineDuration.drawLine = drawline; + m_TimelineDuration.canMoveHead = canMoveHead; + + // Draw the TimeAreaItem + // Rect trackheadRect = treeviewBounds; + //trackheadRect.height = clientArea.height; + m_TimelineDuration.Draw(sequenceRect, state, duration); + } + + // Draw Blue line in timeline indicating the duration... + if (state.editSequence.asset != null && drawhead) + { + HighlightTimeAreaRange(state.editSequence.GetEvaluableRange(), DirectorStyles.Instance.customSkin.colorDurationLine); + } + } + + void HighlightTimeAreaRange(Range range, Color lineColor) + { + if (range.length <= 0.0 || !state.RangeIsVisible(range)) return; + + Rect lineRect = Rect.MinMaxRect( + Math.Max(state.TimeToPixel(range.start), state.timeAreaRect.xMin), + state.timeAreaRect.y - DirectorStyles.kDurationGuiThickness + state.timeAreaRect.height, + Math.Min(state.TimeToPixel(range.end), state.timeAreaRect.xMax), + state.timeAreaRect.y + state.timeAreaRect.height); + EditorGUI.DrawRect(lineRect, lineColor); + } + + // Drag handler for the gui + void OnTrackDurationDrag(double newTime) + { + if (state.editSequence.asset.durationMode == TimelineAsset.DurationMode.FixedLength && !state.editSequence.isReadOnly) + { + // this is the first call to the drag + if (m_TimelineDuration.firstDrag) + { + UndoExtensions.RegisterTimeline(state.editSequence.asset, "Change Duration"); + } + + state.editSequence.asset.fixedDuration = newTime; + + // when setting a new length, modify the duration of the timeline playable directly instead of + // rebuilding the whole graph + state.UpdateRootPlayableDuration(newTime); + } + + m_TimelineDuration.showTooltip = true; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Duration.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Duration.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5828033ac8d0eb50c07b63686a46a1a3bdd76339 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Duration.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5b3bd7a976306c9449ba84e0591e8a0f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_EditorCallbacks.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_EditorCallbacks.cs new file mode 100644 index 0000000000000000000000000000000000000000..2071a9194914ca5fd06048001d0f4fe8d4c48cb6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_EditorCallbacks.cs @@ -0,0 +1,290 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.SceneManagement; +using UnityEngine; +using UnityEngine.Animations; +using UnityEngine.Playables; +using UnityEngine.SceneManagement; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + private int m_ComponentAddedFrame; + + void OnSelectionChangedInactive() + { + // Case 946942 -- when selection changes and the window is open but hidden, timeline + // needs to update selection immediately so preview mode is correctly released + // Case 1123119 -- except when recording + if (!hasFocus) + { + RefreshSelection(!locked && state != null && !state.recording); + } + } + + void InitializeEditorCallbacks() + { + Undo.postprocessModifications += PostprocessAnimationRecordingModifications; + Undo.postprocessModifications += ProcessAssetModifications; + Undo.undoRedoPerformed += OnUndoRedo; + EditorApplication.playModeStateChanged += OnPlayModeStateChanged; + AnimationUtility.onCurveWasModified += OnCurveModified; + EditorApplication.editorApplicationQuit += OnEditorQuit; + Selection.selectionChanged += OnSelectionChangedInactive; + EditorSceneManager.sceneSaved += OnSceneSaved; + ObjectFactory.componentWasAdded += OnComponentWasAdded; + PrefabUtility.prefabInstanceUpdated += OnPrefabApplied; + EditorApplication.pauseStateChanged += OnPlayModePause; + } + + void OnEditorQuit() + { + TimelineWindowViewPrefs.SaveAll(); + } + + void RemoveEditorCallbacks() + { + EditorApplication.playModeStateChanged -= OnPlayModeStateChanged; + + Undo.undoRedoPerformed -= OnUndoRedo; + Undo.postprocessModifications -= PostprocessAnimationRecordingModifications; + Undo.postprocessModifications -= ProcessAssetModifications; + AnimationUtility.onCurveWasModified -= OnCurveModified; + EditorApplication.editorApplicationQuit -= OnEditorQuit; + Selection.selectionChanged -= OnSelectionChangedInactive; + EditorSceneManager.sceneSaved -= OnSceneSaved; + ObjectFactory.componentWasAdded -= OnComponentWasAdded; + PrefabUtility.prefabInstanceUpdated -= OnPrefabApplied; + EditorApplication.pauseStateChanged -= OnPlayModePause; + } + + void OnPlayModePause(PauseState state) + { + // in PlayMode, if the timeline is playing, a constant repaint cycle occurs. Pausing the editor + // breaks the cycle, so this will restart it + Repaint(); + } + + // Called when a prefab change is applied to the scene. + // Redraw so control tracks that use prefabs can show changes + void OnPrefabApplied(GameObject go) + { + if (!state.previewMode) + return; + + // if we added a component this frame, then rebuild, otherwise just let + // the individual playable handle the prefab application + if (Time.frameCount == m_ComponentAddedFrame) + TimelineEditor.Refresh(RefreshReason.ContentsModified); + else + TimelineEditor.Refresh(RefreshReason.SceneNeedsUpdate); + } + + // When the scene is save the director time will get reset. + void OnSceneSaved(Scene scene) + { + if (state != null) + state.OnSceneSaved(); + } + + void OnCurveModified(AnimationClip clip, EditorCurveBinding binding, AnimationUtility.CurveModifiedType type) + { + InspectorWindow.RepaintAllInspectors(); + if (state == null || state.rebuildGraph) + return; + + //Force refresh of curve when modified by another editor. + Repaint(); + + if (state.previewMode == false) + return; + + bool hasPlayable = m_PlayableLookup.GetPlayableFromAnimClip(clip, out Playable playable); + + // mark the timeline clip as dirty + TimelineClip timelineClip = m_PlayableLookup.GetTimelineClipFromCurves(clip); + if (timelineClip != null) + timelineClip.MarkDirty(); + + if (type == AnimationUtility.CurveModifiedType.CurveModified) + { + if (hasPlayable) + { + playable.SetAnimatedProperties(clip); + } + + // updates the duration of the graph without rebuilding + AnimationUtility.SyncEditorCurves(clip); // deleted keys are not synced when this is sent out, so duration could be incorrect + state.UpdateRootPlayableDuration(state.editSequence.duration); + + bool isRecording = TimelineRecording.IsRecordingAnimationTrack; + PlayableDirector masterDirector = TimelineEditor.masterDirector; + bool isGraphValid = masterDirector != null && masterDirector.playableGraph.IsValid(); + + // don't evaluate if this is caused by recording on an animation track, the extra evaluation can cause hiccups + // Prevent graphs to be resurrected by a changed clip. + if (!isRecording && isGraphValid) + state.Evaluate(); + } + else if (EditorUtility.IsDirty(clip)) // curve added/removed, or clip added/removed + { + state.rebuildGraph |= timelineClip != null || hasPlayable; + } + } + + void OnPlayModeStateChanged(PlayModeStateChange playModeState) + { + // case 923506 - make sure we save view data before switching modes + if (playModeState == PlayModeStateChange.ExitingEditMode || + playModeState == PlayModeStateChange.ExitingPlayMode) + TimelineWindowViewPrefs.SaveAll(); + + bool isPlaymodeAboutToChange = playModeState == PlayModeStateChange.ExitingEditMode || playModeState == PlayModeStateChange.ExitingPlayMode; + + // Important to stop the graph on any director so temporary objects are properly cleaned up + if (isPlaymodeAboutToChange && state != null) + state.Stop(); + } + + UndoPropertyModification[] PostprocessAnimationRecordingModifications(UndoPropertyModification[] modifications) + { + DirtyModifiedObjects(modifications); + + var remaining = TimelineRecording.ProcessUndoModification(modifications, state); + // if we've changed, we need to repaint the sequence window to show clip length changes + if (remaining != modifications) + { + // only update if us or the sequencer window has focus + // Prevents color pickers and other dialogs from being wrongly dismissed + bool repaint = (focusedWindow == null) || + (focusedWindow is InspectorWindow) || + (focusedWindow is TimelineWindow); + + if (repaint) + Repaint(); + } + + + return remaining; + } + + void DirtyModifiedObjects(UndoPropertyModification[] modifications) + { + foreach (var m in modifications) + { + if (m.currentValue == null || m.currentValue.target == null) + continue; + + var track = m.currentValue.target as TrackAsset; + var playableAsset = m.currentValue.target as PlayableAsset; + var editorClip = m.currentValue.target as EditorClip; + + if (track != null) + { + track.MarkDirty(); + } + else if (playableAsset != null) + { + var clip = TimelineRecording.FindClipWithAsset(state.editSequence.asset, playableAsset); + if (clip != null) + clip.MarkDirty(); + } + else if (editorClip != null && editorClip.clip != null) + { + editorClip.clip.MarkDirty(); + } + } + } + + UndoPropertyModification[] ProcessAssetModifications(UndoPropertyModification[] modifications) + { + bool rebuildGraph = false; + + for (int i = 0; i < modifications.Length && !rebuildGraph; i++) + { + var mod = modifications[i]; + + // check if an Avatar Mask has been modified + if (mod.previousValue != null && mod.previousValue.target is AvatarMask) + { + rebuildGraph = state.editSequence.asset != null && + state.editSequence.asset.flattenedTracks + .OfType() + .Any(x => mod.previousValue.target == x.avatarMask); + } + } + + if (rebuildGraph) + { + state.rebuildGraph = true; + Repaint(); + } + + return modifications; + } + + void OnUndoRedo() + { + var undos = new List(); + var redos = new List(); + Undo.GetRecords(undos, redos); + + var rebuildAll = redos.Any(x => x.StartsWith("Timeline ")) || undos.Any(x => x.StartsWith("Timeline")); + var evalNow = redos.Any(x => x.Contains("Edit Curve")) || undos.Any(x => x.Contains("Edit Curve")); + if (rebuildAll || evalNow) + { + ValidateSelection(); + if (state != null) + { + if (evalNow) // when curves change, the new values need to be set in the transform before the inspector handles the undo + state.EvaluateImmediate(); + if (rebuildAll) + state.Refresh(); + } + Repaint(); + } + } + + static void ValidateSelection() + { + //get all the clips in the selection + var selectedClips = Selection.GetFiltered(SelectionMode.Unfiltered).Select(x => x.clip); + foreach (var selectedClip in selectedClips) + { + var parent = selectedClip.parentTrack; + if (selectedClip.parentTrack != null) + { + if (!parent.clips.Contains(selectedClip)) + { + SelectionManager.Remove(selectedClip); + } + } + } + } + + void OnComponentWasAdded(Component c) + { + m_ComponentAddedFrame = Time.frameCount; + var go = c.gameObject; + foreach (var seq in state.GetAllSequences()) + { + if (seq.director == null || seq.asset == null) + { + return; + } + + var rebind = seq.asset.GetOutputTracks().Any(track => seq.director.GetGenericBinding(track) == go); + // Either the playable director has a binding for the GameObject or it is a sibling of the director. + // The second case is needed since we have timeline top level markerTracks that do not have a binding, but + // are still "targeting" the playable director + if (rebind || seq.director.gameObject == go) + { + seq.director.RebindPlayableGraphOutputs(); + } + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_EditorCallbacks.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_EditorCallbacks.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..29b3a444463117f990a48a1162c36fb58df4079d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_EditorCallbacks.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d1c9c1ed454d0594b951eb6a76ac62ad +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Gui.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Gui.cs new file mode 100644 index 0000000000000000000000000000000000000000..e5a4879470decaf4c635203e488ea0c7572b4e83 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Gui.cs @@ -0,0 +1,496 @@ +using System; +using System.Collections.Generic; +using UnityEditor.Experimental.SceneManagement; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + struct MarkerOverlay + { + public IMarker marker; + public Rect rect; + public bool isSelected; + public bool isCollapsed; + public MarkerEditor editor; + } + + + enum TimelineItemArea + { + Header, + Lines + } + + [SerializeField] float m_HierarchySplitterPerc = WindowConstants.hierarchySplitterDefaultPercentage; + + static internal readonly TimelineMode s_ActiveMode = new TimelineActiveMode(); + static internal readonly TimelineMode s_EditAssetMode = new TimelineAssetEditionMode(); + static internal readonly TimelineMode s_InactiveMode = new TimelineInactiveMode(); + static internal readonly TimelineMode s_DisabledMode = new TimelineDisabledMode(); + static internal readonly TimelineMode s_PrefabOutOfContextMode = new TimelineAssetEditionMode(); + static internal readonly TimelineMode s_ReadonlyMode = new TimelineReadOnlyMode(); + + int m_SplitterCaptured; + float m_VerticalScrollBarSize, m_HorizontalScrollBarSize; + + List m_OverlayQueue = new List(100); + + + float headerHeight + { + get + { + return WindowConstants.markerRowYPosition + (state.showMarkerHeader ? WindowConstants.markerRowHeight : 0.0f); + } + } + + public Rect markerHeaderRect + { + get { return new Rect(0.0f, WindowConstants.markerRowYPosition, state.sequencerHeaderWidth, WindowConstants.markerRowHeight); } + } + + public Rect markerContentRect + { + get { return Rect.MinMaxRect(state.sequencerHeaderWidth, WindowConstants.markerRowYPosition, position.width, WindowConstants.markerRowYPosition + WindowConstants.markerRowHeight); } + } + + Rect trackRect + { + get + { + var yMinHeight = headerHeight; + return new Rect(0, yMinHeight, position.width, position.height - yMinHeight - horizontalScrollbarHeight); + } + } + + public Rect sequenceRect + { + get { return new Rect(0.0f, WindowConstants.markerRowYPosition, position.width - WindowConstants.sliderWidth, position.height - WindowConstants.timeAreaYPosition); } + } + + public Rect sequenceHeaderRect + { + get { return new Rect(0.0f, WindowConstants.markerRowYPosition, state.sequencerHeaderWidth, position.height - WindowConstants.timeAreaYPosition); } + } + + public Rect sequenceContentRect + { + get + { + return new Rect( + state.sequencerHeaderWidth, + WindowConstants.markerRowYPosition, + position.width - state.sequencerHeaderWidth - (treeView != null && treeView.showingVerticalScrollBar ? WindowConstants.sliderWidth : 0), + position.height - WindowConstants.markerRowYPosition - horizontalScrollbarHeight); + } + } + + public float verticalScrollbarWidth + { + get + { + return m_VerticalScrollBarSize; + } + } + + public float horizontalScrollbarHeight + { + get { return m_HorizontalScrollBarSize; } + } + + internal TimelineMode currentMode + { + get + { + if (state == null || state.editSequence.asset == null) + return s_InactiveMode; + if (state.editSequence.isReadOnly) + return s_ReadonlyMode; + if (state.editSequence.director == null || state.masterSequence.director == null) + return s_EditAssetMode; + + if (PrefabUtility.IsPartOfPrefabAsset(state.editSequence.director)) + { + var stage = PrefabStageUtility.GetCurrentPrefabStage(); + if (stage == null || !stage.IsPartOfPrefabContents(state.editSequence.director.gameObject)) + return s_PrefabOutOfContextMode; + } + + if (!state.masterSequence.director.isActiveAndEnabled) + return s_DisabledMode; + + return s_ActiveMode; + } + } + + void DoLayout() + { + var rawType = Event.current.rawType; // TODO: rawType seems to be broken after calling Use(), use this Hack and remove it once it's fixed. + var mousePosition = Event.current.mousePosition; // mousePosition is also affected by this bug and does not reflect the original position after a Use() + + Initialize(); + HandleSplitterResize(); + + var processManipulators = Event.current.type != EventType.Repaint && Event.current.type != EventType.Layout; + + if (processManipulators) + { + // Update what's under mouse the cursor + PickerUtils.DoPick(state, mousePosition); + + if (state.editSequence.asset != null) + m_PreTreeViewControl.HandleManipulatorsEvents(state); + } + + SequencerGUI(); + + if (processManipulators) + { + if (state.editSequence.asset != null) + m_PostTreeViewControl.HandleManipulatorsEvents(state); + } + + m_RectangleSelect.OnGUI(state, rawType, mousePosition); + m_RectangleZoom.OnGUI(state, rawType, mousePosition); + } + + void SplitterGUI() + { + if (!state.IsEditingAnEmptyTimeline()) + { + var splitterLineRect = new Rect(state.sequencerHeaderWidth - 1.0f, WindowConstants.timeAreaYPosition + 2.0f, 2.0f, clientArea.height); + EditorGUI.DrawRect(splitterLineRect, DirectorStyles.Instance.customSkin.colorTopOutline3); + } + } + + void TrackViewsGUI() + { + using (new GUIViewportScope(trackRect)) + { + TracksGUI(trackRect, state, currentMode.TrackState(state)); + } + } + + void UserOverlaysGUI() + { + if (Event.current.type != EventType.Repaint) + return; + + // the rect containing the time area plus the time ruler + var screenRect = new Rect( + state.sequencerHeaderWidth, + WindowConstants.timeAreaYPosition, + position.width - state.sequencerHeaderWidth - (treeView != null && treeView.showingVerticalScrollBar ? WindowConstants.sliderWidth : 0), + position.height - WindowConstants.timeAreaYPosition - horizontalScrollbarHeight); + + var startTime = state.PixelToTime(screenRect.xMin); + var endTime = state.PixelToTime(screenRect.xMax); + + using (new GUIViewportScope(screenRect)) + { + foreach (var entry in m_OverlayQueue) + { + var uiState = MarkerUIStates.None; + if (entry.isCollapsed) + uiState |= MarkerUIStates.Collapsed; + if (entry.isSelected) + uiState |= MarkerUIStates.Selected; + var region = new MarkerOverlayRegion(GUIClip.Clip(entry.rect), screenRect, startTime, endTime); + try + { + entry.editor.DrawOverlay(entry.marker, uiState, region); + } + catch (Exception e) + { + Debug.LogException(e); + } + } + } + + m_OverlayQueue.Clear(); + } + + void DrawHeaderBackground() + { + var rect = state.timeAreaRect; + rect.xMin = 0.0f; + EditorGUI.DrawRect(rect, DirectorStyles.Instance.customSkin.colorTimelineBackground); + } + + void HandleBottomFillerDragAndDrop(Rect rect) + { + if (Event.current.type != EventType.DragUpdated && + Event.current.type != EventType.DragExited && + Event.current.type != EventType.DragPerform) + return; + + if (instance.treeView == null || instance.treeView.timelineDragging == null) + return; + + if (!rect.Contains(Event.current.mousePosition)) + return; + + instance.treeView.timelineDragging.DragElement(null, new Rect(), -1); + } + + void DrawHeaderBackgroundBottomFiller() + { + var rect = sequenceRect; + rect.yMin = rect.yMax; + rect.yMax = rect.yMax + WindowConstants.sliderWidth; + if (state.editSequence.asset != null && !state.IsEditingAnEmptyTimeline()) + { + rect.width = state.sequencerHeaderWidth; + } + using (new GUIViewportScope(rect)) + { + Graphics.DrawBackgroundRect(state, rect); + } + + HandleBottomFillerDragAndDrop(rect); + } + + void SequencerGUI() + { + var duration = state.editSequence.duration; + + DrawHeaderBackground(); + DurationGUI(TimelineItemArea.Header, duration); + + DrawToolbar(); + + TrackViewsGUI(); + MarkerHeaderGUI(); + UserOverlaysGUI(); + + DurationGUI(TimelineItemArea.Lines, duration); + PlayRangeGUI(TimelineItemArea.Lines); + TimeCursorGUI(TimelineItemArea.Lines); + DrawHeaderBackgroundBottomFiller(); + + SubTimelineRangeGUI(); + + PlayRangeGUI(TimelineItemArea.Header); + TimeCursorGUI(TimelineItemArea.Header); + + SplitterGUI(); + } + + void DrawToolbar() + { + DrawOptions(); + using (new GUILayout.VerticalScope()) + { + using (new GUILayout.HorizontalScope(EditorStyles.toolbar)) + { + using (new GUILayout.HorizontalScope()) + { + DrawTransportToolbar(); + } + + DrawSequenceSelector(); + DrawBreadcrumbs(); + GUILayout.FlexibleSpace(); + DrawOptions(); + } + + using (new GUILayout.HorizontalScope()) + { + DrawHeaderEditButtons(); + DrawTimelineRuler(); + } + } + } + + void SubTimelineRangeGUI() + { + if (!state.IsEditingASubTimeline() || state.IsEditingAnEmptyTimeline()) return; + + var subTimelineOverlayColor = DirectorStyles.Instance.customSkin.colorSubSequenceOverlay; + + var range = state.editSequence.GetEvaluableRange(); + var area = new Vector2(state.TimeToPixel(range.start), state.TimeToPixel(range.end)); + + var fullRect = sequenceContentRect; + fullRect.yMin = WindowConstants.timeAreaYPosition + 1.0f; + + if (fullRect.xMin < area.x) + { + var before = fullRect; + before.xMin = fullRect.xMin; + before.xMax = Mathf.Min(area.x, fullRect.xMax); + EditorGUI.DrawRect(before, subTimelineOverlayColor); + } + + if (fullRect.xMax > area.y) + { + var after = fullRect; + after.xMin = Mathf.Max(area.y, fullRect.xMin); + after.xMax = fullRect.xMax; + EditorGUI.DrawRect(after, subTimelineOverlayColor); + + // Space above the vertical scrollbar + after.xMin = after.xMax; + after.width = verticalScrollbarWidth; + after.yMax = state.timeAreaRect.y + state.timeAreaRect.height + (state.showMarkerHeader ? WindowConstants.markerRowHeight : 0.0f); + EditorGUI.DrawRect(after, subTimelineOverlayColor); + } + } + + void HandleSplitterResize() + { + state.mainAreaWidth = position.width; + + if (state.editSequence.asset == null) + return; + + // Sequencer Header Splitter : The splitter has 6 pixels wide,center it around m_State.sequencerHeaderWidth. That's why there's this -3. + Rect sequencerHeaderSplitterRect = new Rect(state.sequencerHeaderWidth - 3.0f, 0.0f, 6.0f, clientArea.height); + EditorGUIUtility.AddCursorRect(sequencerHeaderSplitterRect, MouseCursor.SplitResizeLeftRight); + + if (Event.current.type == EventType.MouseDown) + { + if (sequencerHeaderSplitterRect.Contains(Event.current.mousePosition)) + m_SplitterCaptured = 1; + } + + if (m_SplitterCaptured > 0) + { + if (Event.current.type == EventType.MouseUp) + { + m_SplitterCaptured = 0; + Event.current.Use(); + } + + if (Event.current.type == EventType.MouseDrag) + { + if (m_SplitterCaptured == 1) + { + var percInc = Event.current.delta.x / position.width; + m_HierarchySplitterPerc = Mathf.Clamp(m_HierarchySplitterPerc + percInc, WindowConstants.minHierarchySplitter, WindowConstants.maxHierarchySplitter); + state.sequencerHeaderWidth += Event.current.delta.x; + } + + Event.current.Use(); + } + } + } + + void DrawOptions() + { + if (currentMode.headerState.options == TimelineModeGUIState.Hidden || state.editSequence.asset == null) + return; + + using (new EditorGUI.DisabledScope(currentMode.headerState.options == TimelineModeGUIState.Disabled)) + { + var rect = new Rect(position.width - WindowConstants.cogButtonWidth, 0, WindowConstants.cogButtonWidth, WindowConstants.timeAreaYPosition); + if (EditorGUI.DropdownButton(rect, DirectorStyles.optionsCogIcon, FocusType.Keyboard, EditorStyles.toolbarButton)) + { + GenericMenu menu = new GenericMenu(); + + menu.AddItem(EditorGUIUtility.TrTextContent("Preferences Page..."), false, () => SettingsWindow.Show(SettingsScope.User, "Preferences/Timeline")); + menu.AddSeparator(""); + + menu.AddItem(EditorGUIUtility.TrTextContent("Seconds"), !state.timeInFrames, ChangeTimeCode, "seconds"); + menu.AddItem(EditorGUIUtility.TrTextContent("Frames"), state.timeInFrames, ChangeTimeCode, "frames"); + menu.AddSeparator(""); + + TimeAreaContextMenu.AddTimeAreaMenuItems(menu, state); + + menu.AddSeparator(""); + + bool standardFrameRate = false; + for (int i = 0; i < TimelineProjectSettings.framerateValues.Length; i++) + { + standardFrameRate |= AddStandardFrameRateMenu(menu, "Frame Rate/" + TimelineProjectSettings.framerateLabels[i], TimelineProjectSettings.framerateValues[i]); + } + + if (standardFrameRate) + menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Frame Rate/Custom")); + else + menu.AddItem(EditorGUIUtility.TrTextContent("Frame Rate/Custom (" + state.editSequence.frameRate + ")"), true, () => {}); + + menu.AddSeparator(""); + if (state.playRangeEnabled) + { + menu.AddItem(EditorGUIUtility.TrTextContent("Play Range Mode/Loop"), state.playRangeLoopMode, () => state.playRangeLoopMode = true); + menu.AddItem(EditorGUIUtility.TrTextContent("Play Range Mode/Once"), !state.playRangeLoopMode, () => state.playRangeLoopMode = false); + } + else + { + menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Play Range Mode")); + } + + if (Unsupported.IsDeveloperMode()) + { + menu.AddSeparator(""); + menu.AddItem(EditorGUIUtility.TrTextContent("Show Snapping Debug"), SnapEngine.displayDebugLayout, + () => SnapEngine.displayDebugLayout = !SnapEngine.displayDebugLayout); + + menu.AddItem(EditorGUIUtility.TrTextContent("Debug TimeArea"), false, + () => + Debug.LogFormat("translation: {0} scale: {1} rect: {2} shownRange: {3}", m_TimeArea.translation, m_TimeArea.scale, m_TimeArea.rect, m_TimeArea.shownArea)); + + menu.AddItem(EditorGUIUtility.TrTextContent("Edit Skin"), false, () => Selection.activeObject = DirectorStyles.Instance.customSkin); + + menu.AddItem(EditorGUIUtility.TrTextContent("Show QuadTree Debugger"), state.showQuadTree, + () => state.showQuadTree = !state.showQuadTree); + } + + menu.DropDown(rect); + } + } + } + + bool AddStandardFrameRateMenu(GenericMenu menu, string name, float value) + { + bool on = state.editSequence.frameRate.Equals(value); + if (state.editSequence.isReadOnly) + { + menu.AddDisabledItem(EditorGUIUtility.TextContent(name), on); + } + else + { + menu.AddItem(EditorGUIUtility.TextContent(name), on, r => + { + state.editSequence.frameRate = value; + }, value); + } + return on; + } + + void ChangeTimeCode(object obj) + { + string format = obj.ToString(); + if (format == "frames") + { + state.timeInFrames = true; + } + else + { + state.timeInFrames = false; + } + } + + public void AddUserOverlay(IMarker marker, Rect rect, MarkerEditor editor, bool collapsed, bool selected) + { + if (marker == null) + throw new ArgumentNullException("marker"); + if (editor == null) + throw new ArgumentNullException("editor"); + + m_OverlayQueue.Add(new MarkerOverlay() + { + isCollapsed = collapsed, + isSelected = selected, + marker = marker, + rect = rect, + editor = editor + } + ); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Gui.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Gui.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..cd727fa528fbc03e95d041590e21d8746221dba3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Gui.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a956e5803e95df349bd35832492d4014 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_HeaderGui.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_HeaderGui.cs new file mode 100644 index 0000000000000000000000000000000000000000..d453218d85ab26256934ad26cd1d753a61a5506c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_HeaderGui.cs @@ -0,0 +1,279 @@ +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + static readonly GUIContent[] k_TimeReferenceGUIContents = + { + EditorGUIUtility.TrTextContent("Local", "Display time based on the current timeline."), + EditorGUIUtility.TrTextContent("Global", "Display time based on the master timeline.") + }; + + TimelineMarkerHeaderGUI m_MarkerHeaderGUI; + + void MarkerHeaderGUI() + { + var timelineAsset = state.editSequence.asset; + if (timelineAsset == null) + return; + + if (m_MarkerHeaderGUI == null) + m_MarkerHeaderGUI = new TimelineMarkerHeaderGUI(timelineAsset, state); + m_MarkerHeaderGUI.Draw(markerHeaderRect, markerContentRect, state); + } + + void DrawTransportToolbar() + { + using (new EditorGUI.DisabledScope(currentMode.PreviewState(state) == TimelineModeGUIState.Disabled)) + { + PreviewModeButtonGUI(); + } + + using (new EditorGUI.DisabledScope(currentMode.ToolbarState(state) == TimelineModeGUIState.Disabled)) + { + GotoBeginingSequenceGUI(); + PreviousEventButtonGUI(); + PlayButtonGUI(); + NextEventButtonGUI(); + GotoEndSequenceGUI(); + PlayRangeButtonGUI(); + TimeCodeGUI(); + ReferenceTimeGUI(); + } + } + + void PreviewModeButtonGUI() + { + if (state.ignorePreview && !Application.isPlaying) + { + GUILayout.Label(DirectorStyles.previewDisabledContent, DirectorStyles.Instance.previewButtonDisabled); + return; + } + + EditorGUI.BeginChangeCheck(); + var enabled = state.previewMode; + enabled = GUILayout.Toggle(enabled, DirectorStyles.previewContent, EditorStyles.toolbarButton); + if (EditorGUI.EndChangeCheck()) + { + // turn off auto play as well, so it doesn't auto reenable + if (!enabled) + { + state.SetPlaying(false); + state.recording = false; + } + + state.previewMode = enabled; + + // if we are successfully enabled, rebuild the graph so initial states work correctly + // Note: testing both values because previewMode setter can "fail" + if (enabled && state.previewMode) + state.rebuildGraph = true; + } + } + + void GotoBeginingSequenceGUI() + { + if (GUILayout.Button(DirectorStyles.gotoBeginingContent, EditorStyles.toolbarButton)) + { + state.editSequence.time = 0; + state.EnsurePlayHeadIsVisible(); + } + } + + // in the editor the play button starts/stops simulation + void PlayButtonGUIEditor() + { + EditorGUI.BeginChangeCheck(); + var isPlaying = GUILayout.Toggle(state.playing, DirectorStyles.playContent, EditorStyles.toolbarButton); + if (EditorGUI.EndChangeCheck()) + { + state.SetPlaying(isPlaying); + } + } + + // in playmode the button reflects the playing state. + // needs to disabled if playing is not possible + void PlayButtonGUIPlayMode() + { + bool buttonEnabled = state.masterSequence.director != null && + state.masterSequence.director.isActiveAndEnabled; + using (new EditorGUI.DisabledScope(!buttonEnabled)) + { + PlayButtonGUIEditor(); + } + } + + void PlayButtonGUI() + { + if (!Application.isPlaying) + PlayButtonGUIEditor(); + else + PlayButtonGUIPlayMode(); + } + + void NextEventButtonGUI() + { + if (GUILayout.Button(DirectorStyles.nextFrameContent, EditorStyles.toolbarButton)) + { + state.referenceSequence.frame += 1; + } + } + + void PreviousEventButtonGUI() + { + if (GUILayout.Button(DirectorStyles.previousFrameContent, EditorStyles.toolbarButton)) + { + state.referenceSequence.frame -= 1; + } + } + + void GotoEndSequenceGUI() + { + if (GUILayout.Button(DirectorStyles.gotoEndContent, EditorStyles.toolbarButton)) + { + state.editSequence.time = state.editSequence.asset.duration; + state.EnsurePlayHeadIsVisible(); + } + } + + void PlayRangeButtonGUI() + { + using (new EditorGUI.DisabledScope(state.ignorePreview || state.IsEditingASubTimeline())) + { + state.playRangeEnabled = GUILayout.Toggle(state.playRangeEnabled, DirectorStyles.Instance.playrangeContent, EditorStyles.toolbarButton); + } + } + + void AddButtonGUI() + { + if (currentMode.trackOptionsState.newButton == TimelineModeGUIState.Hidden) + return; + + using (new EditorGUI.DisabledScope(currentMode.trackOptionsState.newButton == TimelineModeGUIState.Disabled)) + { + if (EditorGUILayout.DropdownButton(DirectorStyles.newContent, FocusType.Passive, EditorStyles.toolbarPopup)) + { + // if there is 1 and only 1 track selected, AND it's a group, add to that group + var groupTracks = SelectionManager.SelectedTracks().ToList(); + if (groupTracks.Any(x => x.GetType() != typeof(GroupTrack) || x.lockedInHierarchy)) + groupTracks = null; + + SequencerContextMenu.ShowNewTracksContextMenu(groupTracks, state, EditorGUILayout.s_LastRect); + } + } + } + + void ShowMarkersButton() + { + var asset = state.editSequence.asset; + if (asset == null) + return; + + var content = state.showMarkerHeader ? DirectorStyles.showMarkersOn : DirectorStyles.showMarkersOff; + SetShowMarkerHeader(GUILayout.Toggle(state.showMarkerHeader, content, DirectorStyles.Instance.showMarkersBtn)); + } + + internal void SetShowMarkerHeader(bool newValue) + { + if (state.showMarkerHeader == newValue) + return; + + TimelineUndo.PushUndo(state.editSequence.viewModel, "Toggle Show Markers"); + state.editSequence.viewModel.showMarkerHeader = newValue; + if (!newValue) + { + var asset = state.editSequence.asset; + if (asset != null && asset.markerTrack != null) + { + SelectionManager.Remove(asset.markerTrack); + foreach (var marker in asset.markerTrack.GetMarkers()) + { + SelectionManager.Remove(marker); + } + } + } + } + + static void EditModeToolbarGUI(TimelineMode mode) + { + using (new EditorGUI.DisabledScope(mode.EditModeButtonsState(instance.state) == TimelineModeGUIState.Disabled)) + { + var editType = EditMode.editType; + + EditorGUI.BeginChangeCheck(); + var mixIcon = editType == EditMode.EditType.Mix ? DirectorStyles.mixOn : DirectorStyles.mixOff; + GUILayout.Toggle(editType == EditMode.EditType.Mix, mixIcon, DirectorStyles.Instance.editModeBtn); + if (EditorGUI.EndChangeCheck()) + EditMode.editType = EditMode.EditType.Mix; + + EditorGUI.BeginChangeCheck(); + var rippleIcon = editType == EditMode.EditType.Ripple ? DirectorStyles.rippleOn : DirectorStyles.rippleOff; + GUILayout.Toggle(editType == EditMode.EditType.Ripple, rippleIcon, DirectorStyles.Instance.editModeBtn); + if (EditorGUI.EndChangeCheck()) + EditMode.editType = EditMode.EditType.Ripple; + + EditorGUI.BeginChangeCheck(); + var replaceIcon = editType == EditMode.EditType.Replace ? DirectorStyles.replaceOn : DirectorStyles.replaceOff; + GUILayout.Toggle(editType == EditMode.EditType.Replace, replaceIcon, DirectorStyles.Instance.editModeBtn); + if (EditorGUI.EndChangeCheck()) + EditMode.editType = EditMode.EditType.Replace; + } + } + + // Draws the box to enter the time field + void TimeCodeGUI() + { + EditorGUI.BeginChangeCheck(); + + var currentTime = state.editSequence.asset != null ? TimeReferenceUtility.ToTimeString(state.editSequence.time, "F1") : "0"; + var r = EditorGUILayout.GetControlRect(false, EditorGUI.kSingleLineHeight, EditorStyles.toolbarTextField, GUILayout.Width(WindowConstants.timeCodeWidth)); + var id = GUIUtility.GetControlID("RenameFieldTextField".GetHashCode(), FocusType.Passive, r); + var newCurrentTime = EditorGUI.DelayedTextFieldInternal(r, id, GUIContent.none, currentTime, null, EditorStyles.toolbarTextField); + + if (EditorGUI.EndChangeCheck()) + state.editSequence.time = TimeReferenceUtility.FromTimeString(newCurrentTime); + } + + void ReferenceTimeGUI() + { + if (!state.IsEditingASubTimeline()) + return; + + EditorGUI.BeginChangeCheck(); + state.timeReferenceMode = (TimeReferenceMode)EditorGUILayout.CycleButton((int)state.timeReferenceMode, k_TimeReferenceGUIContents, DirectorStyles.Instance.timeReferenceButton); + if (EditorGUI.EndChangeCheck()) + OnTimeReferenceModeChanged(); + } + + void OnTimeReferenceModeChanged() + { + m_TimeAreaDirty = true; + InitTimeAreaFrameRate(); + SyncTimeAreaShownRange(); + + foreach (var inspector in InspectorWindow.GetAllInspectorWindows()) + { + inspector.Repaint(); + } + } + + void DrawHeaderEditButtons() + { + if (state.editSequence.asset == null) + return; + + using (new GUILayout.HorizontalScope(EditorStyles.toolbar, GUILayout.Width(sequenceHeaderRect.width))) + { + GUILayout.Space(DirectorStyles.kBaseIndent); + AddButtonGUI(); + GUILayout.FlexibleSpace(); + EditModeToolbarGUI(currentMode); + ShowMarkersButton(); + EditorGUILayout.Space(); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_HeaderGui.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_HeaderGui.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a06ca5fb620223dadc19c08cae9dc963f29b3d08 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_HeaderGui.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fdd19c82588da3e498a0c98951efa6c4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Manipulators.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Manipulators.cs new file mode 100644 index 0000000000000000000000000000000000000000..837ae439793a128ec68ed7468af5d606a73d4ee6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Manipulators.cs @@ -0,0 +1,41 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + readonly Control m_PreTreeViewControl = new Control(); + readonly Control m_PostTreeViewControl = new Control(); + + readonly RectangleSelect m_RectangleSelect = new RectangleSelect(); + readonly RectangleZoom m_RectangleZoom = new RectangleZoom(); + + void InitializeManipulators() + { + // Order is important! + + // Manipulators that needs to be processed BEFORE the treeView (mainly anything clip related) + m_PreTreeViewControl.AddManipulator(new TimelinePanManipulator()); + m_PreTreeViewControl.AddManipulator(new TrackResize()); + m_PreTreeViewControl.AddManipulator(new InlineCurveResize()); + m_PreTreeViewControl.AddManipulator(new TrackZoom()); + m_PreTreeViewControl.AddManipulator(new Jog()); + m_PreTreeViewControl.AddManipulator(TimelineZoomManipulator.Instance); + m_PreTreeViewControl.AddManipulator(new ContextMenuManipulator()); + m_PreTreeViewControl.AddManipulator(new TimelineMarkerHeaderContextMenu()); + + m_PreTreeViewControl.AddManipulator(new EaseClip()); + m_PreTreeViewControl.AddManipulator(new TrimClip()); + m_PreTreeViewControl.AddManipulator(new SelectAndMoveItem()); + m_PreTreeViewControl.AddManipulator(new TrackDoubleClick()); + m_PreTreeViewControl.AddManipulator(new DrillIntoClip()); + m_PreTreeViewControl.AddManipulator(new InlineCurvesShortcutManipulator()); + + // Manipulators that needs to be processed AFTER the treeView or any GUI element able to use event (like inline curves) + m_PostTreeViewControl.AddManipulator(new TimeAreaContextMenu()); + m_PostTreeViewControl.AddManipulator(new TrackShortcutManipulator()); + m_PostTreeViewControl.AddManipulator(new TimelineShortcutManipulator()); + m_PostTreeViewControl.AddManipulator(new ClearSelection()); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Manipulators.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Manipulators.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1bc3569c59c162e2bec3171502616f2c6bedf1be --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Manipulators.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c3a595c9a8ed19040bb2612fe168759d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PlayRange.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PlayRange.cs new file mode 100644 index 0000000000000000000000000000000000000000..99a1ab6633cda9ff98f2fbaef50c7f9467e6cf35 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PlayRange.cs @@ -0,0 +1,131 @@ +using System.Linq; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + TimeAreaItem m_PlayRangeEnd; + TimeAreaItem m_PlayRangeStart; + + void PlayRangeGUI(TimelineItemArea area) + { + if (!currentMode.ShouldShowPlayRange(state) || treeView == null) + return; + + if (state.masterSequence.asset != null && !state.masterSequence.asset.GetRootTracks().Any()) + return; + + // left Time Cursor + if (m_PlayRangeStart == null || m_PlayRangeStart.style != styles.playTimeRangeStart) + { + m_PlayRangeStart = new TimeAreaItem(styles.playTimeRangeStart, OnTrackHeadMinSelectDrag); + Vector2 offset = new Vector2(-2.0f, 0); + m_PlayRangeStart.boundOffset = offset; + } + + // right Time Cursor + if (m_PlayRangeEnd == null || m_PlayRangeEnd.style != styles.playTimeRangeEnd) + { + m_PlayRangeEnd = new TimeAreaItem(styles.playTimeRangeEnd, OnTrackHeadMaxSelectDrag); + Vector2 offset = new Vector2(2.0f, 0); + m_PlayRangeEnd.boundOffset = offset; + } + + if (area == TimelineItemArea.Header) + DrawPlayRange(true, false); + else if (area == TimelineItemArea.Lines) + DrawPlayRange(false, true); + } + + void DrawPlayRange(bool drawHeads, bool drawLines) + { + Rect timeCursorRect = state.timeAreaRect; + timeCursorRect.height = clientArea.height; + + m_PlayRangeEnd.HandleManipulatorsEvents(state); + m_PlayRangeStart.HandleManipulatorsEvents(state); + + // The first time a user enable the play range, we put the play range 75% around the current time... + if (state.playRange == TimelineAssetViewModel.NoPlayRangeSet) + { + float minimumPlayRangeTime = 0.01f; + float t0 = Mathf.Max(0.0f, state.PixelToTime(state.timeAreaRect.xMin)); + float t1 = Mathf.Min((float)state.masterSequence.duration, state.PixelToTime(state.timeAreaRect.xMax)); + + if (Mathf.Abs(t1 - t0) <= minimumPlayRangeTime) + { + state.playRange = new Vector2(t0, t1); + return; + } + + float deltaT = (t1 - t0) * 0.25f / 2.0f; + + t0 += deltaT; + t1 -= deltaT; + + if (t1 < t0) + { + float temp = t0; + t0 = t1; + t1 = temp; + } + + if (Mathf.Abs(t1 - t0) < minimumPlayRangeTime) + { + if (t0 - minimumPlayRangeTime > 0.0f) + t0 -= minimumPlayRangeTime; + else if (t1 + minimumPlayRangeTime < state.masterSequence.duration) + t1 += minimumPlayRangeTime; + } + + state.playRange = new Vector2(t0, t1); + } + + // Draw the head or the lines according to the parameters.. + m_PlayRangeStart.drawHead = drawHeads; + m_PlayRangeStart.drawLine = drawLines; + + m_PlayRangeEnd.drawHead = drawHeads; + m_PlayRangeEnd.drawLine = drawLines; + + var playRangeTime = state.playRange; + m_PlayRangeStart.Draw(sequenceContentRect, state, playRangeTime.x); + m_PlayRangeEnd.Draw(sequenceContentRect, state, playRangeTime.y); + + // Draw Time Range Box from Start to End... + if (state.playRangeEnabled && m_PlayHead != null) + { + Rect rect = + Rect.MinMaxRect( + Mathf.Clamp(state.TimeToPixel(playRangeTime.x), state.timeAreaRect.xMin, state.timeAreaRect.xMax), + m_PlayHead.bounds.yMax, + Mathf.Clamp(state.TimeToPixel(playRangeTime.y), state.timeAreaRect.xMin, state.timeAreaRect.xMax), + sequenceContentRect.height + state.timeAreaRect.height + timeCursorRect.y + ); + + + EditorGUI.DrawRect(rect, DirectorStyles.Instance.customSkin.colorRange); + + rect.height = 3f; + EditorGUI.DrawRect(rect, Color.white); + } + } + + void OnTrackHeadMinSelectDrag(double newTime) + { + Vector2 range = state.playRange; + range.x = (float)newTime; + state.playRange = range; + m_PlayRangeStart.showTooltip = true; + } + + void OnTrackHeadMaxSelectDrag(double newTime) + { + Vector2 range = state.playRange; + range.y = (float)newTime; + state.playRange = range; + m_PlayRangeEnd.showTooltip = true; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PlayRange.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PlayRange.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..dd2e4505e8615b9f889055b76e5967a2cd2038c1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PlayRange.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 14d748c963c7b3549bed45457cc92c4f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PlayableLookup.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PlayableLookup.cs new file mode 100644 index 0000000000000000000000000000000000000000..fbb364867af245ec30cbd63c6e2b3ac82cdb6aa7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PlayableLookup.cs @@ -0,0 +1,79 @@ +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + PlayableLookup m_PlayableLookup = new PlayableLookup(); + + class PlayableLookup + { + const int k_InitialDictionarySize = 10; + + readonly Dictionary m_AnimationClipToPlayable = + new Dictionary(k_InitialDictionarySize); + readonly Dictionary m_AnimationClipToTimelineClip = + new Dictionary(k_InitialDictionarySize); + + public void UpdatePlayableLookup(TimelineClip clip, GameObject go, Playable p) + { + if (clip == null || go == null || !p.IsValid()) + return; + + if (clip.curves != null) + m_AnimationClipToTimelineClip[clip.curves] = clip; + + UpdatePlayableLookup(clip.parentTrack.timelineAsset, clip, go, p); + } + + public void UpdatePlayableLookup(TrackAsset track, GameObject go, Playable p) + { + if (track == null || go == null || !p.IsValid()) + return; + + UpdatePlayableLookup(track.timelineAsset, track, go, p); + } + + void UpdatePlayableLookup(TimelineAsset timelineAsset, ICurvesOwner curvesOwner, GameObject go, Playable p) + { + var director = go.GetComponent(); + var editingDirector = instance.state.editSequence.director; + // No Asset mode update + if (curvesOwner.curves != null && director != null && director == editingDirector && + timelineAsset == instance.state.editSequence.asset) + { + m_AnimationClipToPlayable[curvesOwner.curves] = p; + } + } + + public bool GetPlayableFromAnimClip(AnimationClip clip, out Playable p) + { + if (clip == null) + { + p = Playable.Null; + return false; + } + + return m_AnimationClipToPlayable.TryGetValue(clip, out p); + } + + public TimelineClip GetTimelineClipFromCurves(AnimationClip clip) + { + if (clip == null) + return null; + + TimelineClip timelineClip = null; + m_AnimationClipToTimelineClip.TryGetValue(clip, out timelineClip); + return timelineClip; + } + + public void ClearPlayableLookup() + { + m_AnimationClipToPlayable.Clear(); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PlayableLookup.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PlayableLookup.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..4e0e676b32134e1c550f6aa39d18ededcd326187 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PlayableLookup.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3168bf9e060ff4b46be4bf08e308ce97 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PreviewPlayMode.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PreviewPlayMode.cs new file mode 100644 index 0000000000000000000000000000000000000000..c282e401eef5a5ebd21324af218ce911b520da2a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PreviewPlayMode.cs @@ -0,0 +1,84 @@ +using System; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + void OnPreviewPlayModeChanged(bool isPlaying) + { + if (state != null && !state.ignorePreview && isPlaying) + { + PreparePreviewPlay(); + EditorApplication.update += OnPreviewPlay; + } + else + { + EditorApplication.update -= OnPreviewPlay; + } + } + + void PreparePreviewPlay() + { + if (state == null || state.masterSequence.asset == null || state.masterSequence.director == null) + return; + if (state.playRangeEnabled && !state.isJogging) + { + EnsurePlayRangeIsRespected(); + } + } + + internal void OnPreviewPlay() + { + if (state == null || state.masterSequence.asset == null || state.masterSequence.director == null) + return; + + var director = state.masterSequence.director; + if (director.timeUpdateMode == DirectorUpdateMode.Manual) + { + Repaint(); + return; + } + + if (state.isJogging) + { + ApplyJog(); + } + else if (state.playRangeEnabled) + { + EnsurePlayRangeIsRespected(); + } + + if (director.extrapolationMode == DirectorWrapMode.None && director.playableGraph.IsValid() && !state.playRangeEnabled && director.playableGraph.IsDone()) + { + //reset time if we hit the end of the timeline + state.masterSequence.time = 0.0; + state.Pause(); + } + + Repaint(); + AudioMixerWindow.RepaintAudioMixerWindow(); + } + + void ApplyJog() + { + state.masterSequence.time = Math.Max(0.0, Math.Min(state.masterSequence.duration, state.masterSequence.time + state.playbackSpeed)); + } + + void EnsurePlayRangeIsRespected() + { + var playRangeTime = state.playRange; + var time = state.masterSequence.time; + if (Math.Abs(time - playRangeTime.y) < TimeUtility.kFrameRateEpsilon || time > playRangeTime.y || time < playRangeTime.x) + { + state.masterSequence.time = playRangeTime.x; + // case 1215926 : Special case to make the director mode to play if the wrap mode is None. + // In that mode, the engine stop the graph before we can ensure play range is respected. + if (!state.playing && state.masterSequence.director.extrapolationMode == DirectorWrapMode.None) + state.Play(); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PreviewPlayMode.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PreviewPlayMode.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..7ccfdb9c9d622392568c87766d51d6add68a6543 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_PreviewPlayMode.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5c9c9f62af2efb948a1974650039e2db +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Selection.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Selection.cs new file mode 100644 index 0000000000000000000000000000000000000000..240655db705d99a268aa52938327e7da6abfab6d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Selection.cs @@ -0,0 +1,87 @@ +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + [SerializeField] + SequencePath m_SequencePath; + private Object lastSelectedGO { get; set; } + + void OnSelectionChange() + { + //Sanitize the inline curve selection + SelectionManager.GetCurrentInlineEditorCurve()?.ValidateCurvesSelection(); + + RefreshSelection(false); + } + + void RefreshSelection(bool forceRebuild) + { + // if we're in Locked mode, keep current selection - don't use locked property because the + // sequence hierarchy may need to be rebuilt and it assumes no asset == unlocked + if (m_LockTracker.isLocked || (state != null && state.recording)) + { + RestoreLastSelection(forceRebuild); + return; + } + + // selection is a TimelineAsset + Object selectedObject = Selection.activeObject as TimelineAsset; + if (selectedObject != null) + { + SetCurrentSelection(Selection.activeObject); + return; + } + + // selection is a GameObject, or a prefab with a director + var selectedGO = Selection.activeGameObject; + if (selectedGO != null) + { + bool isSceneObject = !PrefabUtility.IsPartOfPrefabAsset(selectedGO); + bool hasDirector = selectedGO.GetComponent() != null; + if (isSceneObject || hasDirector) + { + SetCurrentSelection(selectedGO); + return; + } + } + + // otherwise, keep the same selection. + RestoreLastSelection(forceRebuild); + } + + void RestoreLastSelection(bool forceRebuild) + { + state.SetCurrentSequencePath(m_SequencePath, forceRebuild); + + //case 1201405 and 1278598: unlock the window if there is no valid asset, since the lock button is disabled + if (m_LockTracker.isLocked && state.editSequence.asset == null) + m_LockTracker.isLocked = false; + } + + void SetCurrentSelection(Object obj) + { + var selectedGameObject = obj as GameObject; + if (selectedGameObject != null) + { + PlayableDirector director = TimelineUtility.GetDirectorComponentForGameObject(selectedGameObject); + SetCurrentTimeline(director); + lastSelectedGO = selectedGameObject; + } + else + { + var selectedSequenceAsset = obj as TimelineAsset; + if (selectedSequenceAsset != null) + { + SetCurrentTimeline(selectedSequenceAsset); + lastSelectedGO = selectedGameObject; + } + } + + Repaint(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Selection.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Selection.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..03c074917724bb71be1850d1f329c770ae38b3bc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_Selection.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 16548db454f7a3344b41ca2e5cdb52b2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_StateChange.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_StateChange.cs new file mode 100644 index 0000000000000000000000000000000000000000..0006eca465d4a4a639815eb147b241b35596b866 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_StateChange.cs @@ -0,0 +1,56 @@ +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + void InitializeStateChange() + { + state.OnPlayStateChange += OnPreviewPlayModeChanged; + state.OnDirtyStampChange += OnStateChange; + state.OnBeforeSequenceChange += OnBeforeSequenceChange; + state.OnAfterSequenceChange += OnAfterSequenceChange; + + state.OnRebuildGraphChange += () => + { + // called when the graph is rebuild, since the UI tree isn't necessarily rebuilt. + if (!state.rebuildGraph) + { + // send callbacks to the tacks + if (treeView != null) + { + var allTrackGuis = treeView.allTrackGuis; + if (allTrackGuis != null) + { + for (int i = 0; i < allTrackGuis.Count; i++) + allTrackGuis[i].OnGraphRebuilt(); + } + } + } + }; + + state.OnTimeChange += () => + { + if (EditorApplication.isPlaying == false) + { + state.UpdateRecordingState(); + EditorApplication.SetSceneRepaintDirty(); + } + + if (state.ignorePreview && state.IsPlayableGraphDone()) + state.Pause(); + + // the time is sync'd prior to the callback + state.Evaluate(); // will do the repaint + + InspectorWindow.RepaintAllInspectors(); + }; + + state.OnRecordingChange += () => + { + if (!state.recording) + { + TrackAssetRecordingExtensions.ClearRecordingState(); + } + }; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_StateChange.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_StateChange.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..65ef3fe4250313ea1469eb38cf7b581ef2e4b3fa --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_StateChange.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b926af22079e00e4a8c073321194cea1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TimeArea.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TimeArea.cs new file mode 100644 index 0000000000000000000000000000000000000000..87f02e485275be0914a593b2ad809d66bba6f2c2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TimeArea.cs @@ -0,0 +1,107 @@ +using System; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + [NonSerialized] TimelineTimeArea m_TimeArea; + public TimeArea timeArea { get { return m_TimeArea; } } + + internal static class Styles + { + public static string DurationModeText = L10n.Tr("Duration Mode/{0}"); + } + + float m_LastFrameRate; + bool m_TimeAreaDirty = true; + + void InitializeTimeArea() + { + if (m_TimeArea == null) + { + m_TimeArea = new TimelineTimeArea(state, false) + { + hRangeLocked = false, + vRangeLocked = true, + margin = 10, + scaleWithWindow = true, + hSlider = true, + vSlider = false, + hBaseRangeMin = 0.0f, + hBaseRangeMax = WindowState.kMaxShownTime, + hRangeMin = 0.0f, + hScaleMax = WindowConstants.maxTimeAreaScaling, + rect = state.timeAreaRect + }; + + m_TimeAreaDirty = true; + InitTimeAreaFrameRate(); + SyncTimeAreaShownRange(); + } + } + + void DrawTimelineRuler() + { + if (!currentMode.ShouldShowTimeArea(state)) + return; + + Rect rect = state.timeAreaRect; + m_TimeArea.rect = new Rect(rect.x, rect.y, rect.width, clientArea.height - rect.y); + + if (m_LastFrameRate != state.referenceSequence.frameRate) + InitTimeAreaFrameRate(); + + SyncTimeAreaShownRange(); + + m_TimeArea.BeginViewGUI(); + m_TimeArea.TimeRuler(rect, state.referenceSequence.frameRate, true, false, 1.0f, state.timeInFrames ? TimeArea.TimeFormat.Frame : TimeArea.TimeFormat.TimeFrame); + m_TimeArea.EndViewGUI(); + } + + void InitTimeAreaFrameRate() + { + m_LastFrameRate = state.referenceSequence.frameRate; + m_TimeArea.hTicks.SetTickModulosForFrameRate(m_LastFrameRate); + } + + void SyncTimeAreaShownRange() + { + var range = state.timeAreaShownRange; + if (!Mathf.Approximately(range.x, m_TimeArea.shownArea.x) || !Mathf.Approximately(range.y, m_TimeArea.shownArea.xMax)) + { + // set view data onto the time area + if (m_TimeAreaDirty) + { + m_TimeArea.SetShownHRange(range.x, range.y); + m_TimeAreaDirty = false; + } + else + { + // set time area data onto the view data + state.TimeAreaChanged(); + } + } + + m_TimeArea.hBaseRangeMax = (float)state.editSequence.duration; + } + + class TimelineTimeArea : TimeArea + { + readonly WindowState m_State; + + public TimelineTimeArea(WindowState state, bool minimalGUI) : base(minimalGUI) + { + m_State = state; + } + + public override string FormatTickTime(float time, float frameRate, TimeFormat timeFormat) + { + time = m_State.timeReferenceMode == TimeReferenceMode.Global ? + (float)m_State.editSequence.ToGlobalTime(time) : time; + + return FormatTime(time, frameRate, timeFormat); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TimeArea.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TimeArea.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..7a001080c7c7a9d91b83cf7b31846bf874982f2f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TimeArea.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b846f69b139b3a341a5699a09fa52b2c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TimeCursor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TimeCursor.cs new file mode 100644 index 0000000000000000000000000000000000000000..9a0bee44391a23b7ef5877f8d04eae27a778c232 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TimeCursor.cs @@ -0,0 +1,83 @@ +using System; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + TimeAreaItem m_PlayHead; + + void TimeCursorGUI(TimelineItemArea area) + { + DrawTimeOnSlider(); + if (!CanDrawTimeCursor(area)) + return; + + if (m_PlayHead == null || m_PlayHead.style != styles.timeCursor) + { + m_PlayHead = new TimeAreaItem(styles.timeCursor, OnTrackHeadDrag); + m_PlayHead.AddManipulator(new PlayheadContextMenu(m_PlayHead)); + } + + var headerMode = area == TimelineItemArea.Header; + DrawTimeCursor(headerMode, !headerMode); + } + + bool CanDrawTimeCursor(TimelineItemArea area) + { + if (!currentMode.ShouldShowTimeCursor(state)) + return false; + + if (treeView == null || state.editSequence.asset == null || (state.editSequence.asset != null && state.IsEditingAnEmptyTimeline())) + return false; + + if (area == TimelineItemArea.Lines && !state.TimeIsInRange((float)state.editSequence.time)) + return false; + + return true; + } + + void DrawTimeOnSlider() + { + if (currentMode.ShouldShowTimeCursor(state)) + { + var colorDimFactor = EditorGUIUtility.isProSkin ? 0.7f : 0.9f; + var c = styles.timeCursor.normal.textColor * colorDimFactor; + + float time = Mathf.Max((float)state.editSequence.time, 0); + float duration = (float)state.editSequence.duration; + + m_TimeArea.DrawTimeOnSlider(time, c, duration, DirectorStyles.kDurationGuiThickness); + } + } + + void DrawTimeCursor(bool drawHead, bool drawline) + { + m_PlayHead.HandleManipulatorsEvents(state); + + if (Event.current.type == EventType.MouseDown && Event.current.button == 0) + { + if (state.timeAreaRect.Contains(Event.current.mousePosition)) + { + state.SetPlaying(false); + m_PlayHead.HandleManipulatorsEvents(state); + state.editSequence.time = Math.Max(0.0, state.GetSnappedTimeAtMousePosition(Event.current.mousePosition)); + } + } + + state.isClipSnapping = false; + + m_PlayHead.drawLine = drawline; + m_PlayHead.drawHead = drawHead; + m_PlayHead.Draw(sequenceContentRect, state, state.editSequence.time); + } + + void OnTrackHeadDrag(double newTime) + { + state.editSequence.time = Math.Max(0.0, newTime); + m_PlayHead.showTooltip = true; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TimeCursor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TimeCursor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..44d5a83ad14b3259879f9bd207d135dd08366e69 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TimeCursor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e763a90581e2d8143bc9a0e384ce6f0f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TrackGui.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TrackGui.cs new file mode 100644 index 0000000000000000000000000000000000000000..d55290b05aa32d144401a492b42c8aa32fe36131 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TrackGui.cs @@ -0,0 +1,216 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + partial class TimelineWindow + { + public TimelineTreeViewGUI treeView { get; private set; } + + void TracksGUI(Rect clientRect, WindowState state, TimelineModeGUIState trackState) + { + if (Event.current.type == EventType.Repaint && treeView != null) + { + state.headerSpacePartitioner.Clear(); + state.spacePartitioner.Clear(); + } + + if (state.IsEditingASubTimeline() && !state.IsEditingAnEmptyTimeline()) + { + var headerRect = clientRect; + headerRect.width = state.sequencerHeaderWidth; + Graphics.DrawBackgroundRect(state, headerRect); + + var clipRect = clientRect; + clipRect.xMin = headerRect.xMax; + Graphics.DrawBackgroundRect(state, clipRect, subSequenceMode: true); + } + else + { + Graphics.DrawBackgroundRect(state, clientRect); + } + + if (!state.IsEditingAnEmptyTimeline()) + m_TimeArea.DrawMajorTicks(sequenceContentRect, state.referenceSequence.frameRate); + + GUILayout.BeginVertical(); + { + GUILayout.Space(5.0f); + GUILayout.BeginHorizontal(); + + if (this.state.editSequence.asset == null) + DrawNoSequenceGUI(state); + else + DrawTracksGUI(clientRect, trackState); + + GUILayout.EndHorizontal(); + } + GUILayout.EndVertical(); + + Graphics.DrawShadow(clientRect); + } + + void DrawNoSequenceGUI(WindowState windowState) + { + bool showCreateButton = false; + var currentlySelectedGo = UnityEditor.Selection.activeObject != null ? UnityEditor.Selection.activeObject as GameObject : null; + var textContent = DirectorStyles.noTimelineAssetSelected; + var existingDirector = currentlySelectedGo != null ? currentlySelectedGo.GetComponent() : null; + var existingAsset = existingDirector != null ? existingDirector.playableAsset : null; + + if (currentlySelectedGo != null && !TimelineUtility.IsPrefabOrAsset(currentlySelectedGo) && existingAsset == null) + { + showCreateButton = true; + textContent = new GUIContent(String.Format(DirectorStyles.createTimelineOnSelection.text, currentlySelectedGo.name, "a Director component and a Timeline asset")); + } + GUILayout.FlexibleSpace(); + GUILayout.BeginVertical(); + GUILayout.FlexibleSpace(); + + GUILayout.Label(textContent); + + if (showCreateButton) + { + GUILayout.BeginHorizontal(); + var textSize = GUI.skin.label.CalcSize(textContent); + GUILayout.Space((textSize.x / 2.0f) - (WindowConstants.createButtonWidth / 2.0f)); + if (GUILayout.Button("Create", GUILayout.Width(WindowConstants.createButtonWidth))) + { + var message = DirectorStyles.createNewTimelineText.text + " '" + currentlySelectedGo.name + "'"; + var defaultName = currentlySelectedGo.name.EndsWith(DirectorStyles.newTimelineDefaultNameSuffix, StringComparison.OrdinalIgnoreCase) + ? currentlySelectedGo.name + : currentlySelectedGo.name + DirectorStyles.newTimelineDefaultNameSuffix; + + // Use the project window path by default only if it's under the asset folder. + // Otherwise the saveFilePanel will reject the save (case 1289923) + var defaultPath = ProjectWindowUtil.GetActiveFolderPath(); + if (!defaultPath.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase)) + defaultPath = "Assets"; + + string newSequencePath = EditorUtility.SaveFilePanelInProject(DirectorStyles.createNewTimelineText.text, defaultName, "playable", message, defaultPath); + if (!string.IsNullOrEmpty(newSequencePath)) + { + var newAsset = TimelineUtility.CreateAndSaveTimelineAsset(newSequencePath); + + Undo.IncrementCurrentGroup(); + + if (existingDirector == null) + { + existingDirector = Undo.AddComponent(currentlySelectedGo); + } + + existingDirector.playableAsset = newAsset; + SetCurrentTimeline(existingDirector); + windowState.previewMode = false; + } + + // If we reach this point, the state of the panel has changed; skip the rest of this GUI phase + // Fixes: case 955831 - [OSX] NullReferenceException when creating a timeline on a selected object + GUIUtility.ExitGUI(); + } + GUILayout.EndHorizontal(); + } + GUILayout.FlexibleSpace(); + GUILayout.EndVertical(); + GUILayout.FlexibleSpace(); + } + + public enum OverlayDataTypes + { + None, + BackgroundColor, + BackgroundTexture, + TextBox + } + + public struct OverlayData + { + public OverlayDataTypes types { get; private set; } + public Rect rect { get; internal set; } + public string text { get; private set; } + public Texture2D texture { get; private set; } + public Color color { get; private set; } + public GUIStyle backgroundTextStyle { get; private set; } + public GUIStyle textStyle { get; private set; } + + public static OverlayData CreateColorOverlay(Rect rectangle, Color backgroundColor) + { + OverlayData data = new OverlayData(); + data.rect = rectangle; + data.color = backgroundColor; + data.types = OverlayDataTypes.BackgroundColor; + return data; + } + + public static OverlayData CreateTextureOverlay(Rect rectangle, Texture2D backTexture) + { + OverlayData data = new OverlayData(); + data.rect = rectangle; + data.texture = backTexture; + data.types = OverlayDataTypes.BackgroundTexture; + return data; + } + + public static OverlayData CreateTextBoxOverlay(Rect rectangle, string msg, GUIStyle textstyle, Color textcolor, Color bgTextColor, GUIStyle bgTextStyle) + { + OverlayData data = new OverlayData(); + data.rect = rectangle; + data.text = msg; + data.textStyle = textstyle; + data.textStyle.normal.textColor = textcolor; + data.backgroundTextStyle = bgTextStyle; + data.backgroundTextStyle.normal.textColor = bgTextColor; + data.types = OverlayDataTypes.TextBox; + return data; + } + } + + internal List OverlayDrawData = new List(); + + void DrawTracksGUI(Rect clientRect, TimelineModeGUIState trackState) + { + GUILayout.BeginVertical(GUILayout.Height(clientRect.height)); + if (treeView != null) + { + if (Event.current.type == EventType.Layout) + { + OverlayDrawData.Clear(); + } + + treeView.OnGUI(clientRect); + + if (Event.current.type == EventType.Repaint) + { + foreach (var overlayData in OverlayDrawData) + { + using (new GUIViewportScope(sequenceContentRect)) + DrawOverlay(overlayData); + } + } + } + GUILayout.EndVertical(); + } + + void DrawOverlay(OverlayData overlayData) + { + Rect overlayRect = GUIClip.Clip(overlayData.rect); + if (overlayData.types == OverlayDataTypes.BackgroundColor) + { + EditorGUI.DrawRect(overlayRect, overlayData.color); + } + else if (overlayData.types == OverlayDataTypes.BackgroundTexture) + { + Graphics.DrawTextureRepeated(overlayRect, overlayData.texture); + } + else if (overlayData.types == OverlayDataTypes.TextBox) + { + using (new GUIColorOverride(overlayData.backgroundTextStyle.normal.textColor)) + GUI.Box(overlayRect, GUIContent.none, overlayData.backgroundTextStyle); + Graphics.ShadowLabel(overlayRect, GUIContent.Temp(overlayData.text), overlayData.textStyle, overlayData.textStyle.normal.textColor, Color.black); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TrackGui.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TrackGui.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..d90b49f514ae20a102513e632bc52e5d720acfed --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/TimelineWindow_TrackGui.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 08d23c0b73905c148b525c3c93fff580 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel.meta new file mode 100644 index 0000000000000000000000000000000000000000..d9d92e332b76905ad10ab8823aac5b4a06418b0f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: b9d7bb79ed0c2854a8a5ed7decc3e44f +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/ScriptableObjectViewPrefs.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/ScriptableObjectViewPrefs.cs new file mode 100644 index 0000000000000000000000000000000000000000..66b5cb8681fd9e5a87e7adcf48ff2d07843e5add --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/ScriptableObjectViewPrefs.cs @@ -0,0 +1,119 @@ +using System; +using System.IO; +using UnityEditorInternal; +using UnityEngine; +using UnityObject = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class ScriptableObjectViewPrefs : IDisposable where TViewModel : ScriptableObject + { + const string k_DefaultFilePath = "Library/"; + const string k_Extension = ".pref"; + + readonly string m_RelativePath; + readonly string m_AbsolutePath; + readonly string m_FileName; + ScriptableObject m_Asset; + TViewModel m_ViewModel; + + bool isSavable + { + get + { + return m_Asset != null && + m_ViewModel != null && + !string.IsNullOrEmpty(m_FileName); + } + } + + public ScriptableObjectViewPrefs(ScriptableObject asset, string relativeSavePath) + { + m_Asset = asset; + m_RelativePath = string.IsNullOrEmpty(relativeSavePath) ? k_DefaultFilePath : relativeSavePath; + if (!m_RelativePath.EndsWith("/", StringComparison.Ordinal)) + m_RelativePath += "/"; + + m_AbsolutePath = Application.dataPath + "/../" + m_RelativePath; + + var assetKey = GetAssetKey(asset); + m_FileName = string.IsNullOrEmpty(assetKey) ? string.Empty : assetKey + k_Extension; + } + + public TViewModel viewModel + { + get + { + if (m_ViewModel == null) + { + if (m_Asset == null) + m_ViewModel = CreateViewModel(); + else + m_ViewModel = LoadViewModel() ?? CreateViewModel(); + } + return m_ViewModel; + } + } + + public void Save() + { + if (!isSavable) + return; + + // make sure the path exists or file write will fail + if (!Directory.Exists(m_AbsolutePath)) + Directory.CreateDirectory(m_AbsolutePath); + + const bool saveAsText = true; + InternalEditorUtility.SaveToSerializedFileAndForget(new UnityObject[] { m_ViewModel }, m_RelativePath + m_FileName, saveAsText); + } + + public void DeleteFile() + { + if (!isSavable) + return; + + var path = m_AbsolutePath + m_FileName; + + if (!File.Exists(path)) + return; + + File.Delete(path); + } + + public void Dispose() + { + if (m_ViewModel != null) + UnityObject.DestroyImmediate(m_ViewModel); + + m_Asset = null; + } + + public static TViewModel CreateViewModel() + { + var model = ScriptableObject.CreateInstance(); + model.hideFlags |= HideFlags.HideAndDontSave; + return model; + } + + TViewModel LoadViewModel() + { + if (string.IsNullOrEmpty(m_FileName)) + return null; + + var objects = InternalEditorUtility.LoadSerializedFileAndForget(m_RelativePath + m_FileName); + if (objects.Length <= 0 || objects[0] == null) + return null; + + var model = (TViewModel)objects[0]; + model.hideFlags |= HideFlags.HideAndDontSave; + + return model; + } + + static string GetAssetKey(UnityObject asset) + { + return asset == null ? string.Empty : AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(asset)); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/ScriptableObjectViewPrefs.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/ScriptableObjectViewPrefs.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..7201defe49375997a15a922004cd783c3e0052d6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/ScriptableObjectViewPrefs.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 80ae83fdf1fb2c649bccb8c293b94556 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/TimelineAssetViewModel.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/TimelineAssetViewModel.cs new file mode 100644 index 0000000000000000000000000000000000000000..538cb4eb7f223a0ff0de9503d97c2fc2c60c0e88 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/TimelineAssetViewModel.cs @@ -0,0 +1,116 @@ +using System; +using System.Collections.Generic; +using UnityEditor.IMGUI.Controls; +using UnityEngine; +using UnityEngine.Timeline; +using UnityObject = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + [Serializable] + class TrackViewModelData : ISerializationCallbackReceiver + { + public static readonly float DefaultinlineAnimationCurveHeight = 100.0f; + + public bool collapsed = true; + public bool showMarkers = true; + + public bool showInlineCurves = false; + public float inlineAnimationCurveHeight = DefaultinlineAnimationCurveHeight; + public int lastInlineCurveDataID = -1; + public TreeViewState inlineCurvesState = null; + public Rect inlineCurvesShownAreaInsideMargins = new Rect(1, 1, 1, 1); + public int trackHeightExtension; + + public Dictionary markerTimeStamps = new Dictionary(); + [SerializeField] List m_MarkerTimeStampsKeys; + [SerializeField] List m_MarkerTimeStampsValues; + + public void OnBeforeSerialize() + { + if (markerTimeStamps == null) + return; + + m_MarkerTimeStampsKeys = new List(markerTimeStamps.Count); + m_MarkerTimeStampsValues = new List(markerTimeStamps.Count); + + foreach (var kvp in markerTimeStamps) + { + m_MarkerTimeStampsKeys.Add(kvp.Key); + m_MarkerTimeStampsValues.Add(kvp.Value); + } + } + + public void OnAfterDeserialize() + { + markerTimeStamps = new Dictionary(); + + if (m_MarkerTimeStampsKeys == null || m_MarkerTimeStampsValues == null || + m_MarkerTimeStampsKeys.Count != m_MarkerTimeStampsValues.Count) + return; + + for (int i = 0; i < m_MarkerTimeStampsKeys.Count; ++i) + markerTimeStamps.Add(m_MarkerTimeStampsKeys[i], m_MarkerTimeStampsValues[i]); + } + } + + [Serializable] + class TimelineAssetViewModel : ScriptableObject, ISerializationCallbackReceiver + { + public const float DefaultTrackScale = 1.0f; + public const float DefaultVerticalScroll = 0; + + public static readonly Vector2 TimeAreaDefaultRange = new Vector2(-WindowConstants.timeAreaShownRangePadding, 5.0f); // in seconds. Hack: using negative value to force the UI to have a left margin at 0. + public static readonly Vector2 NoPlayRangeSet = new Vector2(float.MaxValue, float.MaxValue); + + public Vector2 timeAreaShownRange = TimeAreaDefaultRange; + public float trackScale = DefaultTrackScale; + public bool playRangeEnabled; + public Vector2 timeAreaPlayRange = NoPlayRangeSet; + public double windowTime; + public float verticalScroll = DefaultVerticalScroll; + public bool showMarkerHeader; + public float sequencerHeaderWidth = WindowConstants.defaultHeaderWidth; + + public Dictionary tracksViewModelData = new Dictionary(); + + // Used only for serialization of the dictionary + [SerializeField] List m_Keys = new List(); + [SerializeField] List m_Vals = new List(); + + public void OnBeforeSerialize() + { + m_Keys.Clear(); + m_Vals.Clear(); + foreach (var data in tracksViewModelData) + { + // Assets that don't save, will create nulls when deserializeds + if (data.Key != null && data.Value != null && (data.Key.hideFlags & HideFlags.DontSave) == 0) + { + m_Keys.Add(data.Key); + m_Vals.Add(data.Value); + } + } + } + + public void OnAfterDeserialize() + { + } + + public void OnEnable() + { + if (m_Keys.Count == m_Vals.Count) + { + tracksViewModelData.Clear(); + for (int i = 0; i < m_Keys.Count; i++) + { + if (m_Keys[i] != null) // if the asset is overwritten the tracks can be null + tracksViewModelData[m_Keys[i]] = m_Vals[i]; + } + } + + m_Keys.Clear(); + m_Vals.Clear(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/TimelineAssetViewModel.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/TimelineAssetViewModel.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..7a8e1702390a84e5303e1cb5695462b8f172f03f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/TimelineAssetViewModel.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d79cb9ecc0d4a6d428ab98a681a33897 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/TimelineWindowViewPrefs.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/TimelineWindowViewPrefs.cs new file mode 100644 index 0000000000000000000000000000000000000000..ab0b85037ed9f7de872434c375d4e39275665f23 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/TimelineWindowViewPrefs.cs @@ -0,0 +1,184 @@ +using UnityEngine; +using UnityEngine.Timeline; +using UnityObject = UnityEngine.Object; +using ViewModelsMap = System.Collections.Generic.Dictionary>; +using ViewModelsList = System.Collections.Generic.List>; + +namespace UnityEditor.Timeline +{ + static class TimelineWindowViewPrefs + { + public const string FilePath = "Library/Timeline"; + + static readonly ViewModelsMap k_ViewModelsMap = new ViewModelsMap(); + static readonly ViewModelsList k_UnassociatedViewModels = new ViewModelsList(); + + public static int viewModelCount + { + get { return k_ViewModelsMap.Count + k_UnassociatedViewModels.Count; } + } + + public static TimelineAssetViewModel GetOrCreateViewModel(TimelineAsset asset) + { + if (asset == null) + return CreateUnassociatedViewModel(); + + ScriptableObjectViewPrefs vm; + if (k_ViewModelsMap.TryGetValue(asset, out vm)) + return vm.viewModel; + + return CreateViewModel(asset).viewModel; + } + + public static TimelineAssetViewModel CreateUnassociatedViewModel() + { + var vm = new ScriptableObjectViewPrefs(null, FilePath); + k_UnassociatedViewModels.Add(vm); + return vm.viewModel; + } + + static ScriptableObjectViewPrefs CreateViewModel(TimelineAsset asset) + { + var vm = new ScriptableObjectViewPrefs(asset, FilePath); + k_ViewModelsMap.Add(asset, vm); + return vm; + } + + public static void SaveViewModel(TimelineAsset asset) + { + if (asset == null) + return; + + ScriptableObjectViewPrefs vm; + if (!k_ViewModelsMap.TryGetValue(asset, out vm)) + vm = CreateViewModel(asset); + + vm.Save(); + } + + public static void SaveAll() + { + foreach (var kvp in k_ViewModelsMap) + kvp.Value.Save(); + } + + public static void UnloadViewModel(TimelineAsset asset) + { + ScriptableObjectViewPrefs vm; + if (k_ViewModelsMap.TryGetValue(asset, out vm)) + { + vm.Dispose(); + k_ViewModelsMap.Remove(asset); + } + } + + public static void UnloadAllViewModels() + { + foreach (var kvp in k_ViewModelsMap) + kvp.Value.Dispose(); + + foreach (var vm in k_UnassociatedViewModels) + vm.Dispose(); + + k_ViewModelsMap.Clear(); + k_UnassociatedViewModels.Clear(); + } + + public static TrackViewModelData GetTrackViewModelData(TrackAsset track) + { + if (track == null) + return new TrackViewModelData(); + + if (track.timelineAsset == null) + return new TrackViewModelData(); + + var prefs = GetOrCreateViewModel(track.timelineAsset); + + TrackViewModelData trackData; + if (prefs.tracksViewModelData.TryGetValue(track, out trackData)) + { + return trackData; + } + + trackData = new TrackViewModelData(); + prefs.tracksViewModelData[track] = trackData; + return trackData; + } + + public static bool IsTrackCollapsed(TrackAsset track) + { + if (track == null) + return true; + + return GetTrackViewModelData(track).collapsed; + } + + public static void SetTrackCollapsed(TrackAsset track, bool collapsed) + { + if (track == null) + return; + + GetTrackViewModelData(track).collapsed = collapsed; + } + + public static bool IsShowMarkers(TrackAsset track) + { + if (track == null) + return true; + + return GetTrackViewModelData(track).showMarkers; + } + + public static void SetTrackShowMarkers(TrackAsset track, bool collapsed) + { + if (track == null) + return; + + GetTrackViewModelData(track).showMarkers = collapsed; + } + + public static bool GetShowInlineCurves(TrackAsset track) + { + if (track == null) + return false; + + return GetTrackViewModelData(track).showInlineCurves; + } + + public static void SetShowInlineCurves(TrackAsset track, bool inlineOn) + { + if (track == null) + return; + + GetTrackViewModelData(track).showInlineCurves = inlineOn; + } + + public static float GetInlineCurveHeight(TrackAsset asset) + { + if (asset == null) + return TrackViewModelData.DefaultinlineAnimationCurveHeight; + + return GetTrackViewModelData(asset).inlineAnimationCurveHeight; + } + + public static void SetInlineCurveHeight(TrackAsset asset, float height) + { + if (asset != null) + GetTrackViewModelData(asset).inlineAnimationCurveHeight = height; + } + + public static int GetTrackHeightExtension(TrackAsset asset) + { + if (asset == null) + return 0; + + return GetTrackViewModelData(asset).trackHeightExtension; + } + + public static void SetTrackHeightExtension(TrackAsset asset, int height) + { + if (asset != null) + GetTrackViewModelData(asset).trackHeightExtension = height; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/TimelineWindowViewPrefs.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/TimelineWindowViewPrefs.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..9501d6da629d48f897f48788adc3dd7015d2502d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/ViewModel/TimelineWindowViewPrefs.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 105515c1653548242b4fe973c0f375f7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/WindowConstants.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/WindowConstants.cs new file mode 100644 index 0000000000000000000000000000000000000000..36626ae7f1016c165e42e11d85b395a5053cf02b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/WindowConstants.cs @@ -0,0 +1,46 @@ +namespace UnityEditor.Timeline +{ + static class WindowConstants + { + public const float timeAreaYPosition = 19.0f; + public const float timeAreaHeight = 22.0f; + public const float timeAreaMinWidth = 50.0f; + public const float timeAreaShownRangePadding = 5.0f; + + public const float markerRowHeight = 18.0f; + public const float markerRowYPosition = timeAreaYPosition + timeAreaHeight; + + public const float defaultHeaderWidth = 315.0f; + public const float defaultBindingAreaWidth = 40.0f; + + public const float minHierarchySplitter = 0.15f; + public const float maxHierarchySplitter = 10.50f; + public const float hierarchySplitterDefaultPercentage = 0.2f; + + public const float minHeaderWidth = 195.0f; + public const float maxHeaderWidth = 650.0f; + + public const float maxTimeAreaScaling = 90000.0f; + public const float timeCodeWidth = 100.0f; // Enough space to display up to 9999 without clipping + + public const float sliderWidth = 15; + public const float shadowUnderTimelineHeight = 15.0f; + public const float createButtonWidth = 70.0f; + + public const float selectorWidth = 23.0f; + public const float cogButtonWidth = 25.0f; + + public const float trackHeaderButtonSize = 16.0f; + public const float trackHeaderButtonPadding = 2.0f; + public const float trackBindingMaxSize = 300.0f; + public const float trackBindingPadding = 5.0f; + + public const float trackInsertionMarkerHeight = 1f; + public const float trackResizeHandleHeight = 7f; + public const float inlineCurveContentPadding = 2.0f; + + public const float playControlsWidth = 300; + + public const int autoPanPaddingInPixels = 50; + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/WindowConstants.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/WindowConstants.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..9fb0cfa5e717ca0d34e6da93907e872436ff73b9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Window/WindowConstants.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6d768b1bb52e2c64ba818933dbdd8452 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/AnimationPlayableAssetInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/AnimationPlayableAssetInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..40db7e67d142c7ddb0bb4fb422678bc816b4f9d6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/AnimationPlayableAssetInspector.cs @@ -0,0 +1,341 @@ +using System; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [CustomEditor(typeof(AnimationPlayableAsset)), CanEditMultipleObjects] + class AnimationPlayableAssetInspector : Editor + { + static class Styles + { + public static readonly GUIContent RotationText = EditorGUIUtility.TrTextContent("Rotation"); + public static readonly GUIContent AnimClipText = EditorGUIUtility.TrTextContent("Animation Clip"); + public static readonly GUIContent TransformOffsetTitle = EditorGUIUtility.TrTextContent("Clip Transform Offsets", "Use this to offset the root transform position and rotation relative to the track when playing this clip"); + public static readonly GUIContent AnimationClipName = EditorGUIUtility.TrTextContent("Animation Clip Name"); + public static readonly GUIContent MatchTargetFieldsTitle = EditorGUIUtility.TrTextContent("Offsets Match Fields", "Fields to apply when matching offsets on clips. The defaults can be set on the track."); + public static readonly GUIContent UseDefaults = EditorGUIUtility.TrTextContent("Use defaults"); + public static readonly GUIContent RemoveStartOffset = EditorGUIUtility.TrTextContent("Remove Start Offset", "Makes playback of the clip play relative to first key of the root transform"); + public static readonly GUIContent ApplyFootIK = EditorGUIUtility.TrTextContent("Foot IK", "Enable to apply foot IK to the AnimationClip when the target is humanoid."); + public static readonly GUIContent Loop = EditorGUIUtility.TrTextContent("Loop", "Whether the source Animation Clip loops during playback."); + } + + TimelineWindow m_TimelineWindow; + GameObject m_Binding; + + TimelineAnimationUtilities.OffsetEditMode m_OffsetEditMode = TimelineAnimationUtilities.OffsetEditMode.None; + EditorClip m_EditorClip; + EditorClip[] m_EditorClips; + + SerializedProperty m_PositionProperty; + SerializedProperty m_RotationProperty; + SerializedProperty m_AnimClipProperty; + SerializedProperty m_UseTrackMatchFieldsProperty; + SerializedProperty m_MatchTargetFieldsProperty; + SerializedObject m_SerializedAnimClip; + SerializedProperty m_SerializedAnimClipName; + SerializedProperty m_RemoveStartOffsetProperty; + SerializedProperty m_ApplyFootIK; + SerializedProperty m_Loop; + + Vector3 m_LastPosition; + Vector3 m_LastRotation; + + public override void OnInspectorGUI() + { + if (target == null) + return; + + serializedObject.Update(); + + if (!m_TimelineWindow) m_TimelineWindow = TimelineWindow.instance; + + ShowAnimationClipField(); + ShowRecordableClipRename(); + ShowAnimationClipWarnings(); + + EditorGUI.BeginChangeCheck(); + + TransformOffsetsGUI(); + + // extra checks are because the context menu may need to cause a re-evaluate + bool changed = EditorGUI.EndChangeCheck() || + m_LastPosition != m_PositionProperty.vector3Value || + m_LastRotation != m_RotationProperty.vector3Value; + m_LastPosition = m_PositionProperty.vector3Value; + m_LastRotation = m_RotationProperty.vector3Value; + + if (changed) + { + // updates the changed properties and pushes them to the active playable + serializedObject.ApplyModifiedProperties(); + ((AnimationPlayableAsset)target).LiveLink(); + + // force an evaluate to happen next frame + if (TimelineWindow.instance != null && TimelineWindow.instance.state != null) + { + TimelineWindow.instance.state.Evaluate(); + } + } + + EditorGUI.BeginChangeCheck(); + EditorGUILayout.PropertyField(m_ApplyFootIK, Styles.ApplyFootIK); + EditorGUILayout.PropertyField(m_Loop, Styles.Loop); + if (EditorGUI.EndChangeCheck()) + TimelineEditor.Refresh(RefreshReason.ContentsModified); + + serializedObject.ApplyModifiedProperties(); + } + + void ShowAnimationClipField() + { + bool disabled = m_EditorClips == null || m_EditorClips.Any(c => c.clip == null || c.clip.recordable); + using (new EditorGUI.DisabledScope(disabled)) + { + EditorGUI.BeginChangeCheck(); + EditorGUILayout.PropertyField(m_AnimClipProperty, Styles.AnimClipText); + if (EditorGUI.EndChangeCheck()) + { + // rename the timeline clips to match the animation name if it did previously + if (m_AnimClipProperty.objectReferenceValue != null && m_EditorClips != null) + { + var newName = m_AnimClipProperty.objectReferenceValue.name; + foreach (var c in m_EditorClips) + { + if (c == null || c.clip == null || c.clip.asset == null) + continue; + + var apa = c.clip.asset as AnimationPlayableAsset; + if (apa != null && apa.clip != null && c.clip.displayName == apa.clip.name) + { + if (c.clip.parentTrack != null) + Undo.RegisterCompleteObjectUndo(c.clip.parentTrack, "Inspector"); + c.clip.displayName = newName; + } + } + } + + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + } + } + + void TransformOffsetsMatchFieldsGUI() + { + var rect = EditorGUILayout.GetControlRect(true); + EditorGUI.BeginProperty(rect, Styles.MatchTargetFieldsTitle, m_UseTrackMatchFieldsProperty); + + rect = EditorGUI.PrefixLabel(rect, Styles.MatchTargetFieldsTitle); + int oldIndent = EditorGUI.indentLevel; + EditorGUI.indentLevel = 0; + EditorGUI.BeginChangeCheck(); + bool val = m_UseTrackMatchFieldsProperty.boolValue; + val = EditorGUI.ToggleLeft(rect, Styles.UseDefaults, val); + if (EditorGUI.EndChangeCheck()) + m_UseTrackMatchFieldsProperty.boolValue = val; + + EditorGUI.indentLevel = oldIndent; + EditorGUI.EndProperty(); + + + if (!val || m_UseTrackMatchFieldsProperty.hasMultipleDifferentValues) + { + EditorGUI.indentLevel++; + AnimationTrackInspector.MatchTargetsFieldGUI(m_MatchTargetFieldsProperty); + EditorGUI.indentLevel--; + } + } + + void TransformOffsetsGUI() + { + if (ShouldShowOffsets()) + { + EditorGUILayout.Space(); + EditorGUILayout.LabelField(Styles.TransformOffsetTitle); + EditorGUI.indentLevel++; + + using (new EditorGUI.DisabledScope(targets.Length > 1)) + { + var previousOffsetMode = m_OffsetEditMode; + AnimationTrackInspector.ShowMotionOffsetEditModeToolbar(ref m_OffsetEditMode); + if (previousOffsetMode != m_OffsetEditMode) + { + SetTimeToClip(); + SceneView.RepaintAll(); + } + } + + EditorGUILayout.BeginHorizontal(); + EditorGUILayout.PropertyField(m_PositionProperty); + EditorGUILayout.EndHorizontal(); + + EditorGUILayout.BeginHorizontal(); + EditorGUILayout.PropertyField(m_RotationProperty, Styles.RotationText); + EditorGUILayout.EndHorizontal(); + + EditorGUILayout.Space(); + + EditorGUI.indentLevel--; + + TransformOffsetsMatchFieldsGUI(); + + EditorGUI.BeginChangeCheck(); + EditorGUILayout.PropertyField(m_RemoveStartOffsetProperty, Styles.RemoveStartOffset); + if (EditorGUI.EndChangeCheck()) + { + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + Repaint(); + } + } + } + + void Reevaluate() + { + if (m_TimelineWindow != null && m_TimelineWindow.state != null) + { + m_TimelineWindow.state.Refresh(); + m_TimelineWindow.state.EvaluateImmediate(); + } + } + + // Make sure the director time is within the bounds of the clip + void SetTimeToClip() + { + if (m_TimelineWindow != null && m_TimelineWindow.state != null) + { + m_TimelineWindow.state.editSequence.time = Math.Min(m_EditorClip.clip.end, Math.Max(m_EditorClip.clip.start, m_TimelineWindow.state.editSequence.time)); + } + } + + public void OnEnable() + { + if (target == null) // case 946080 + return; + + m_EditorClip = UnityEditor.Selection.activeObject as EditorClip; + m_EditorClips = UnityEditor.Selection.objects.OfType().ToArray(); + SceneView.duringSceneGui += OnSceneGUI; + + m_PositionProperty = serializedObject.FindProperty("m_Position"); + m_PositionProperty.isExpanded = true; + m_RotationProperty = serializedObject.FindProperty("m_EulerAngles"); + m_AnimClipProperty = serializedObject.FindProperty("m_Clip"); + m_UseTrackMatchFieldsProperty = serializedObject.FindProperty("m_UseTrackMatchFields"); + m_MatchTargetFieldsProperty = serializedObject.FindProperty("m_MatchTargetFields"); + m_RemoveStartOffsetProperty = serializedObject.FindProperty("m_RemoveStartOffset"); + m_ApplyFootIK = serializedObject.FindProperty("m_ApplyFootIK"); + m_Loop = serializedObject.FindProperty("m_Loop"); + + m_LastPosition = m_PositionProperty.vector3Value; + m_LastRotation = m_RotationProperty.vector3Value; + } + + void OnDestroy() + { + SceneView.duringSceneGui -= OnSceneGUI; + } + + void OnSceneGUI(SceneView sceneView) + { + DoManipulators(); + } + + Transform GetTransform() + { + if (m_Binding != null) + return m_Binding.transform; + + if (m_TimelineWindow != null && m_TimelineWindow.state != null && + m_TimelineWindow.state.editSequence.director != null && + m_EditorClip != null && m_EditorClip.clip != null) + { + var obj = TimelineUtility.GetSceneGameObject(m_TimelineWindow.state.editSequence.director, + m_EditorClip.clip.parentTrack); + m_Binding = obj; + if (obj != null) + return obj.transform; + } + return null; + } + + 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 ShowAnimationClipWarnings() + { + AnimationClip clip = m_AnimClipProperty.objectReferenceValue as AnimationClip; + if (clip == null) + { + EditorGUILayout.HelpBox(AnimationPlayableAssetEditor.k_NoClipAssignedError, MessageType.Warning); + } + else if (clip.legacy) + { + EditorGUILayout.HelpBox(AnimationPlayableAssetEditor.k_LegacyClipError, MessageType.Warning); + } + } + + bool ShouldShowOffsets() + { + return targets.OfType().All(x => x.hasRootTransforms); + } + + void ShowRecordableClipRename() + { + if (targets.Length > 1 || m_EditorClip == null || m_EditorClip.clip == null || !m_EditorClip.clip.recordable) + return; + + AnimationClip clip = m_AnimClipProperty.objectReferenceValue as AnimationClip; + if (clip == null || !AssetDatabase.IsSubAsset(clip)) + return; + + if (m_SerializedAnimClip == null) + { + m_SerializedAnimClip = new SerializedObject(clip); + m_SerializedAnimClipName = m_SerializedAnimClip.FindProperty("m_Name"); + } + + if (m_SerializedAnimClipName != null) + { + m_SerializedAnimClip.Update(); + EditorGUI.BeginChangeCheck(); + EditorGUILayout.DelayedTextField(m_SerializedAnimClipName, Styles.AnimationClipName); + if (EditorGUI.EndChangeCheck()) + m_SerializedAnimClip.ApplyModifiedProperties(); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/AnimationPlayableAssetInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/AnimationPlayableAssetInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..b81fe247269c2ef9925835b7ec9723a86b824595 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/AnimationPlayableAssetInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f7852b99951997645ae7adaac5f0b083 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/AnimationTrackInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/AnimationTrackInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..69dbcc6acf5a7eb8e6a2412348bb53372c638514 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/AnimationTrackInspector.cs @@ -0,0 +1,516 @@ +//#define PERF_PROFILE + +using System; +using System.ComponentModel; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + [CustomEditor(typeof(AnimationTrack)), CanEditMultipleObjects] + class AnimationTrackInspector : TrackAssetInspector + { + static class Styles + { + public static GUIContent MatchTargetFieldsTitle = EditorGUIUtility.TrTextContent("Default Offset Match Fields", "Fields to apply when matching offsets on clips. These are the defaults, and can be overridden for each clip."); + public static readonly GUIContent PositionIcon = EditorGUIUtility.IconContent("MoveTool"); + public static readonly GUIContent RotationIcon = EditorGUIUtility.IconContent("RotateTool"); + + public static GUIContent XTitle = EditorGUIUtility.TextContent("X"); + public static GUIContent YTitle = EditorGUIUtility.TextContent("Y"); + public static GUIContent ZTitle = EditorGUIUtility.TextContent("Z"); + public static GUIContent PositionTitle = EditorGUIUtility.TrTextContent("Position"); + public static GUIContent RotationTitle = EditorGUIUtility.TrTextContent("Rotation"); + + public static readonly GUIContent OffsetModeTitle = EditorGUIUtility.TrTextContent("Track Offsets"); + public static readonly string TransformOffsetInfo = L10n.Tr("Transform offsets are applied to the entire track. Use this mode to play the animation track at a fixed position and rotation."); + public static readonly string SceneOffsetInfo = L10n.Tr("Scene offsets will use the existing transform as initial offsets. Use this to play the track from the gameObjects current position and rotation."); + public static readonly string AutoOffsetInfo = L10n.Tr("Auto will apply scene offsets if there is a controller attached to the animator and transform offsets otherwise."); + public static readonly string AutoOffsetWarning = L10n.Tr("This mode is deprecated may be removed in a future release."); + public static readonly string InheritedFromParent = L10n.Tr("Inherited"); + public static readonly string InheritedToolTip = L10n.Tr("This value is inherited from it's parent track."); + + public static readonly string AvatarMaskWarning = L10n.Tr("Applying an Avatar Mask to the base track may not properly mask Root Motion or Humanoid bones from an Animator Controller or other Timeline track."); + + public static readonly GUIContent RecordingOffsets = EditorGUIUtility.TrTextContent("Recorded Offsets", "Offsets applied to recorded position and rotation keys"); + public static readonly GUIContent RecordingIkApplied = EditorGUIUtility.TrTextContent("Apply Foot IK", "Applies Foot IK to recorded Animation."); + + public static readonly GUIContent[] OffsetContents; + public static readonly GUIContent[] OffsetInheritContents; + + static Styles() + { + var values = Enum.GetValues(typeof(TrackOffset)); + OffsetContents = new GUIContent[values.Length]; + OffsetInheritContents = new GUIContent[values.Length]; + for (var index = 0; index < values.Length; index++) + { + var offset = (TrackOffset)index; + var name = ObjectNames.NicifyVariableName(L10n.Tr(offset.ToString())); + var memInfo = typeof(TrackOffset).GetMember(offset.ToString()); + var attributes = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false); + if (attributes.Length > 0) + { + name = ((DescriptionAttribute)attributes[0]).Description; + } + + OffsetContents[index] = new GUIContent(name); + OffsetInheritContents[index] = new GUIContent(string.Format("{0} ({1})", InheritedFromParent, name)); + } + } + } + + TimelineAnimationUtilities.OffsetEditMode m_OffsetEditMode = TimelineAnimationUtilities.OffsetEditMode.None; + + SerializedProperty m_MatchFieldsProperty; + SerializedProperty m_TrackPositionProperty; + SerializedProperty m_TrackRotationProperty; + SerializedProperty m_AvatarMaskProperty; + SerializedProperty m_ApplyAvatarMaskProperty; + SerializedProperty m_TrackOffsetProperty; + + SerializedProperty m_RecordedOffsetPositionProperty; + SerializedProperty m_RecordedOffsetEulerProperty; + SerializedProperty m_RecordedApplyFootIK; + + Vector3 m_lastPosition; + Vector3 m_lastRotation; + + GUIContent m_TempContent = new GUIContent(); + + + void Evaluate() + { + if (timelineWindow.state != null && timelineWindow.state.editSequence.director != null) + { + // force the update immediately, the deferred doesn't always work with the inspector + timelineWindow.state.editSequence.director.Evaluate(); + } + } + + void RebuildGraph() + { + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + public override void OnInspectorGUI() + { + using (new EditorGUI.DisabledScope(IsTrackLocked())) + { + serializedObject.Update(); + + DrawRootTransformOffset(); + + EditorGUI.BeginChangeCheck(); + DrawRecordedProperties(); + DrawAvatarProperties(); + if (EditorGUI.EndChangeCheck()) + RebuildGraph(); + + DrawMatchFieldsGUI(); + + serializedObject.ApplyModifiedProperties(); + } + } + + bool AnimatesRootTransform() + { + return targets.OfType().All(t => t.AnimatesRootTransform()); + } + + bool ShouldDrawOffsets() + { + bool hasMultiple; + var offsetMode = GetOffsetMode(out hasMultiple); + if (hasMultiple) + return false; + + if (offsetMode == TrackOffset.ApplySceneOffsets) + return false; + + if (offsetMode == TrackOffset.ApplyTransformOffsets) + return true; + + // Auto mode. + PlayableDirector director = this.m_Context as PlayableDirector; + if (director == null) + return false; + + // If any bound animators have controllers don't show + foreach (var track in targets.OfType()) + { + var animator = track.GetBinding(director); + if (animator != null && animator.runtimeAnimatorController != null) + return false; + } + + return true; + } + + void DrawRootTransformOffset() + { + if (!AnimatesRootTransform()) + return; + + bool showWarning = SetupOffsetTooltip(); + DrawRootTransformDropDown(); + + if (ShouldDrawOffsets()) + { + EditorGUI.indentLevel++; + DrawRootMotionToolBar(); + DrawRootMotionOffsetFields(); + EditorGUI.indentLevel--; + } + + if (showWarning) + { + EditorGUI.indentLevel++; + EditorGUILayout.HelpBox(Styles.AutoOffsetWarning, MessageType.Warning, true); + EditorGUI.indentLevel--; + } + } + + bool SetupOffsetTooltip() + { + Styles.OffsetModeTitle.tooltip = string.Empty; + bool hasMultiple; + var offsetMode = GetOffsetMode(out hasMultiple); + bool showWarning = false; + if (!hasMultiple) + { + if (offsetMode == TrackOffset.ApplyTransformOffsets) + Styles.OffsetModeTitle.tooltip = Styles.TransformOffsetInfo; + else if (offsetMode == TrackOffset.ApplySceneOffsets) + Styles.OffsetModeTitle.tooltip = Styles.SceneOffsetInfo; + else if (offsetMode == TrackOffset.Auto) + { + Styles.OffsetModeTitle.tooltip = Styles.AutoOffsetInfo; + showWarning = true; + } + } + + return showWarning; + } + + void DrawRootTransformDropDown() + { + bool anySubTracks = targets.OfType().Any(t => t.isSubTrack); + bool allSubTracks = targets.OfType().All(t => t.isSubTrack); + + bool mixed; + var rootOffsetMode = GetOffsetMode(out mixed); + + // if we are showing subtracks, we need to show the current mode from the parent + // BUT keep it disabled + if (anySubTracks) + { + m_TempContent.tooltip = string.Empty; + if (mixed) + m_TempContent.text = EditorGUI.mixedValueContent.text; + else if (!allSubTracks) + m_TempContent.text = Styles.OffsetContents[(int)rootOffsetMode].text; + else + { + m_TempContent.text = Styles.OffsetInheritContents[(int)rootOffsetMode].text; + m_TempContent.tooltip = Styles.InheritedToolTip; + } + + using (new EditorGUI.DisabledScope(true)) + EditorGUILayout.LabelField(Styles.OffsetModeTitle, m_TempContent, EditorStyles.popup); + } + else + { + // We use an enum popup explicitly because it will handle the description attribute on the enum + using (new GUIMixedValueScope(mixed)) + { + var rect = EditorGUILayout.GetControlRect(true, EditorGUI.kSingleLineHeight); + EditorGUI.BeginProperty(rect, Styles.OffsetModeTitle, m_TrackOffsetProperty); + EditorGUI.BeginChangeCheck(); + var result = (TrackOffset)EditorGUI.EnumPopup(rect, Styles.OffsetModeTitle, (TrackOffset)m_TrackOffsetProperty.intValue); + if (EditorGUI.EndChangeCheck()) + { + m_TrackOffsetProperty.enumValueIndex = (int)result; + + // this property changes the recordable state of the objects, so auto disable recording + if (TimelineWindow.instance != null) + { + if (TimelineWindow.instance.state != null) + TimelineWindow.instance.state.recording = false; + RebuildGraph(); + } + } + + EditorGUI.EndProperty(); + } + } + } + + void DrawMatchFieldsGUI() + { + if (!AnimatesRootTransform()) + return; + + m_MatchFieldsProperty.isExpanded = EditorGUILayout.Foldout(m_MatchFieldsProperty.isExpanded, Styles.MatchTargetFieldsTitle, true); + if (m_MatchFieldsProperty.isExpanded) + { + EditorGUI.indentLevel++; + MatchTargetsFieldGUI(m_MatchFieldsProperty); + EditorGUI.indentLevel--; + } + } + + void DrawRootMotionOffsetFields() + { + EditorGUI.BeginChangeCheck(); + + EditorGUILayout.BeginHorizontal(); + EditorGUILayout.PropertyField(m_TrackPositionProperty); + EditorGUILayout.EndHorizontal(); + + EditorGUILayout.BeginHorizontal(); + EditorGUILayout.PropertyField(m_TrackRotationProperty, Styles.RotationTitle); + EditorGUILayout.EndHorizontal(); + EditorGUILayout.Space(); + EditorGUILayout.Space(); + + if (EditorGUI.EndChangeCheck()) + { + UpdateOffsets(); + } + } + + void DrawRootMotionToolBar() + { + bool disable = targets.Length > 1; + bool changed = false; + + if (!disable) + { + // detects external changes + changed |= m_lastPosition != m_TrackPositionProperty.vector3Value || m_lastRotation != m_TrackRotationProperty.vector3Value; + m_lastPosition = m_TrackPositionProperty.vector3Value; + m_lastRotation = m_TrackRotationProperty.vector3Value; + SceneView.RepaintAll(); + } + + EditorGUI.BeginChangeCheck(); + using (new EditorGUI.DisabledScope(disable)) + ShowMotionOffsetEditModeToolbar(ref m_OffsetEditMode); + changed |= EditorGUI.EndChangeCheck(); + + if (changed) + { + UpdateOffsets(); + } + } + + void UpdateOffsets() + { + foreach (var track in targets.OfType()) + track.UpdateClipOffsets(); + Evaluate(); + } + + void DrawAvatarProperties() + { + EditorGUILayout.PropertyField(m_ApplyAvatarMaskProperty); + if (m_ApplyAvatarMaskProperty.hasMultipleDifferentValues || m_ApplyAvatarMaskProperty.boolValue) + { + EditorGUI.indentLevel++; + EditorGUILayout.PropertyField(m_AvatarMaskProperty); + EditorGUI.indentLevel--; + } + + if (targets.OfType().Any(x => !x.isSubTrack)) + EditorGUILayout.HelpBox(Styles.AvatarMaskWarning, MessageType.Warning); + + EditorGUILayout.Space(); + } + + public static void ShowMotionOffsetEditModeToolbar(ref TimelineAnimationUtilities.OffsetEditMode motionOffset) + { + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + GUILayout.FlexibleSpace(); + + int newMotionOffsetMode = GUILayout.Toolbar((int)motionOffset, new[] { Styles.PositionIcon, Styles.RotationIcon }); + + if (GUI.changed) + { + if ((int)motionOffset == newMotionOffsetMode) //untoggle the button + motionOffset = TimelineAnimationUtilities.OffsetEditMode.None; + else + motionOffset = (TimelineAnimationUtilities.OffsetEditMode)newMotionOffsetMode; + } + + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + GUILayout.Space(3); + } + + public override void OnEnable() + { + base.OnEnable(); + SceneView.duringSceneGui += OnSceneGUI; + + m_MatchFieldsProperty = serializedObject.FindProperty("m_MatchTargetFields"); + m_TrackPositionProperty = serializedObject.FindProperty("m_Position"); + m_TrackRotationProperty = serializedObject.FindProperty("m_EulerAngles"); + m_TrackOffsetProperty = serializedObject.FindProperty("m_TrackOffset"); + m_AvatarMaskProperty = serializedObject.FindProperty("m_AvatarMask"); + m_ApplyAvatarMaskProperty = serializedObject.FindProperty("m_ApplyAvatarMask"); + m_RecordedOffsetPositionProperty = serializedObject.FindProperty("m_InfiniteClipOffsetPosition"); + m_RecordedOffsetEulerProperty = serializedObject.FindProperty("m_InfiniteClipOffsetEulerAngles"); + m_RecordedApplyFootIK = serializedObject.FindProperty("m_InfiniteClipApplyFootIK"); + + m_lastPosition = m_TrackPositionProperty.vector3Value; + m_lastRotation = m_TrackRotationProperty.vector3Value; + } + + public void OnDestroy() + { + SceneView.duringSceneGui -= OnSceneGUI; + } + + void OnSceneGUI(SceneView sceneView) + { + DoOffsetManipulator(); + } + + 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, "Inspector"); + TimelineAnimationUtilities.UpdateTrackOffset(animationTrack, boundObjectTransform, offsets); + Evaluate(); + Repaint(); + } + } + } + + public void DrawRecordedProperties() + { + // only show if this applies to all targets + foreach (var track in targets) + { + var animationTrack = track as AnimationTrack; + if (animationTrack == null || animationTrack.inClipMode || animationTrack.infiniteClip == null || animationTrack.infiniteClip.empty) + return; + } + + GUILayout.Label(Styles.RecordingOffsets); + EditorGUI.indentLevel++; + EditorGUILayout.BeginHorizontal(); + EditorGUILayout.PropertyField(m_RecordedOffsetPositionProperty, Styles.PositionTitle); + EditorGUILayout.EndHorizontal(); + + EditorGUILayout.BeginHorizontal(); + EditorGUILayout.PropertyField(m_RecordedOffsetEulerProperty, Styles.RotationTitle); + EditorGUILayout.EndHorizontal(); + EditorGUI.indentLevel--; + EditorGUILayout.Space(); + + EditorGUILayout.PropertyField(m_RecordedApplyFootIK, Styles.RecordingIkApplied); + EditorGUILayout.Space(); + } + + public static void MatchTargetsFieldGUI(SerializedProperty property) + { + const float ToggleWidth = 20; + int value = 0; + + MatchTargetFields enumValue = (MatchTargetFields)property.intValue; + + EditorGUI.BeginChangeCheck(); + Rect rect = EditorGUILayout.GetControlRect(false, kLineHeight * 2); + Rect itemRect = new Rect(rect.x, rect.y, rect.width, kLineHeight); + EditorGUI.BeginProperty(rect, Styles.MatchTargetFieldsTitle, property); + float minWidth = 0, maxWidth = 0; + EditorStyles.label.CalcMinMaxWidth(Styles.XTitle, out minWidth, out maxWidth); + float width = minWidth + ToggleWidth; + + GUILayout.BeginHorizontal(); + Rect r = EditorGUI.PrefixLabel(itemRect, Styles.PositionTitle); + int oldIndent = EditorGUI.indentLevel; + EditorGUI.indentLevel = 0; + r.width = width; + value |= EditorGUI.ToggleLeft(r, Styles.XTitle, enumValue.HasAny(MatchTargetFields.PositionX)) ? (int)MatchTargetFields.PositionX : 0; + r.x += width; + value |= EditorGUI.ToggleLeft(r, Styles.YTitle, enumValue.HasAny(MatchTargetFields.PositionY)) ? (int)MatchTargetFields.PositionY : 0; + r.x += width; + value |= EditorGUI.ToggleLeft(r, Styles.ZTitle, enumValue.HasAny(MatchTargetFields.PositionZ)) ? (int)MatchTargetFields.PositionZ : 0; + EditorGUI.indentLevel = oldIndent; + GUILayout.EndHorizontal(); + + GUILayout.BeginHorizontal(); + itemRect.y += kLineHeight; + r = EditorGUI.PrefixLabel(itemRect, Styles.RotationTitle); + EditorGUI.indentLevel = 0; + r.width = width; + value |= EditorGUI.ToggleLeft(r, Styles.XTitle, enumValue.HasAny(MatchTargetFields.RotationX)) ? (int)MatchTargetFields.RotationX : 0; + r.x += width; + value |= EditorGUI.ToggleLeft(r, Styles.YTitle, enumValue.HasAny(MatchTargetFields.RotationY)) ? (int)MatchTargetFields.RotationY : 0; + r.x += width; + value |= EditorGUI.ToggleLeft(r, Styles.ZTitle, enumValue.HasAny(MatchTargetFields.RotationZ)) ? (int)MatchTargetFields.RotationZ : 0; + EditorGUI.indentLevel = oldIndent; + GUILayout.EndHorizontal(); + + EditorGUI.EndProperty(); + if (EditorGUI.EndChangeCheck()) + { + property.intValue = value; + } + } + + static TrackOffset GetOffsetMode(AnimationTrack track) + { + if (track.isSubTrack) + { + var parent = track.parent as AnimationTrack; + if (parent != null) // fallback to the current track if there is an error + track = parent; + } + + return track.trackOffset; + } + + // gets the current mode, + TrackOffset GetOffsetMode(out bool hasMultiple) + { + var rootOffsetMode = GetOffsetMode(target as AnimationTrack); + hasMultiple = targets.OfType().Any(t => GetOffsetMode(t) != rootOffsetMode); + return rootOffsetMode; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/AnimationTrackInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/AnimationTrackInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..3f57ed421d3f481fb9a81a46fb6f0c82e3debe5b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/AnimationTrackInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: edc553b1b3c8a25438b62783410b26ae +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/BasicAssetInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/BasicAssetInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..d746c9f36c8999c86df472176e9182bcebbcbfbc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/BasicAssetInspector.cs @@ -0,0 +1,41 @@ +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + // Simple inspector used by built in assets + // that only need to hide the script field + class BasicAssetInspector : Editor + { + public override void OnInspectorGUI() + { + EditorGUI.BeginChangeCheck(); + serializedObject.Update(); + + SerializedProperty property = serializedObject.GetIterator(); + bool expanded = true; + while (property.NextVisible(expanded)) + { + expanded = false; + if (SkipField(property.propertyPath)) + continue; + EditorGUILayout.PropertyField(property, true); + } + + serializedObject.ApplyModifiedProperties(); + EditorGUI.EndChangeCheck(); + } + + public virtual void ApplyChanges() + { + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + static bool SkipField(string fieldName) + { + return fieldName == "m_Script"; + } + } + + [CustomEditor(typeof(ActivationPlayableAsset))] + class ActivationPlayableAssetInspector : BasicAssetInspector {} +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/BasicAssetInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/BasicAssetInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..f296b755fa39849d31962f106ae0713bebf79f65 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/BasicAssetInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e086b15460c228c4f9b116f0e3e2f175 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/BuiltInCurvePresets.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/BuiltInCurvePresets.cs new file mode 100644 index 0000000000000000000000000000000000000000..2e5c8cf230ea5abef26ff5bfd4451c2c7447a9d2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/BuiltInCurvePresets.cs @@ -0,0 +1,58 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + // Preset libraries + static class BuiltInPresets + { + static CurvePresetLibrary s_BlendInPresets; + static CurvePresetLibrary s_BlendOutPresets; + + internal static CurvePresetLibrary blendInPresets + { + get + { + if (s_BlendInPresets == null) + { + s_BlendInPresets = ScriptableObject.CreateInstance(); + s_BlendInPresets.Add(new AnimationCurve(CurveEditorWindow.GetConstantKeys(1f)), "None"); + s_BlendInPresets.Add(new AnimationCurve(CurveEditorWindow.GetLinearKeys()), "Linear"); + s_BlendInPresets.Add(new AnimationCurve(CurveEditorWindow.GetEaseInKeys()), "EaseIn"); + s_BlendInPresets.Add(new AnimationCurve(CurveEditorWindow.GetEaseOutKeys()), "EaseOut"); + s_BlendInPresets.Add(new AnimationCurve(CurveEditorWindow.GetEaseInOutKeys()), "EaseInOut"); + } + return s_BlendInPresets; + } + } + + internal static CurvePresetLibrary blendOutPresets + { + get + { + if (s_BlendOutPresets == null) + { + s_BlendOutPresets = ScriptableObject.CreateInstance(); + s_BlendOutPresets.Add(new AnimationCurve(CurveEditorWindow.GetConstantKeys(1f)), "None"); + s_BlendOutPresets.Add(ReverseCurve(new AnimationCurve(CurveEditorWindow.GetLinearKeys())), "Linear"); + s_BlendOutPresets.Add(ReverseCurve(new AnimationCurve(CurveEditorWindow.GetEaseInKeys())), "EaseIn"); + s_BlendOutPresets.Add(ReverseCurve(new AnimationCurve(CurveEditorWindow.GetEaseOutKeys())), "EaseOut"); + s_BlendOutPresets.Add(ReverseCurve(new AnimationCurve(CurveEditorWindow.GetEaseInOutKeys())), "EaseInOut"); + } + return s_BlendOutPresets; + } + } + + static AnimationCurve ReverseCurve(AnimationCurve curve) + { + Keyframe[] keys = curve.keys; + for (int i = 0; i < keys.Length; i++) + { + keys[i].value = 1 - keys[i].value; + keys[i].inTangent *= -1; + keys[i].outTangent *= -1; + } + curve.keys = keys; + return curve; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/BuiltInCurvePresets.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/BuiltInCurvePresets.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..d294670b3af64518117b1f49f1df8a7586560738 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/BuiltInCurvePresets.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ae05f0dd1cf145e4e8e905c7971ee433 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/ClipInspector.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/ClipInspector.meta new file mode 100644 index 0000000000000000000000000000000000000000..1774e4e62876f283fdb070f5a561364688460233 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/ClipInspector.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: f68c7f7359094f045930a108c444e7a4 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/CurvesOwner.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/CurvesOwner.meta new file mode 100644 index 0000000000000000000000000000000000000000..309cb0a1a70deada5eace5d8d9dc95098b82e67f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/CurvesOwner.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 86cacab070a0a46e99aedb596a32c4fe +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/DirectorNamedColorInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/DirectorNamedColorInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..5646870c8ee710b9bf2f84df6994939eb9dd6bb5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/DirectorNamedColorInspector.cs @@ -0,0 +1,27 @@ +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + /// + /// Internally used Inspector + /// + [CustomEditor(typeof(DirectorNamedColor))] + class DirectorNamedColorInspector : Editor + { + public override void OnInspectorGUI() + { + base.OnInspectorGUI(); + if (GUILayout.Button("ToTextAsset")) + { + DirectorStyles.Instance.ExportSkinToFile(); + } + + if (GUILayout.Button("Reload From File")) + { + DirectorStyles.Instance.ReloadSkin(); + UnityEditor.Selection.activeObject = DirectorStyles.Instance.customSkin; + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/DirectorNamedColorInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/DirectorNamedColorInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..250f3d43957389441da3034823d09fabcb41dcf4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/DirectorNamedColorInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9c8ceb9efacb4974bb3b7e2a87137b07 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/EditorClip.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/EditorClip.cs new file mode 100644 index 0000000000000000000000000000000000000000..edd3d9d22c68cd4f9df645eca99819846eb7cc1f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/EditorClip.cs @@ -0,0 +1,24 @@ +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [ExcludeFromPreset] + class EditorClip : ScriptableObject + { + [SerializeField] TimelineClip m_Clip; + + public TimelineClip clip + { + get { return m_Clip; } + set { m_Clip = value; } + } + + public int lastHash { get; set; } + + public override int GetHashCode() + { + return clip.Hash(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/EditorClip.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/EditorClip.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1887ce2553441c6d9ca460de475dc4f320d12d5b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/EditorClip.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 197c1114eb793d24c8ef31120a134e88 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/EditorClipFactory.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/EditorClipFactory.cs new file mode 100644 index 0000000000000000000000000000000000000000..d065b37e1af73671361437cf90c39e6d3cae2945 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/EditorClipFactory.cs @@ -0,0 +1,53 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Timeline; +using UnityObject = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + static class EditorClipFactory + { + static Dictionary s_EditorCache = new Dictionary(); + + public static EditorClip GetEditorClip(TimelineClip clip) + { + if (clip == null) + throw new ArgumentException("parameter cannot be null"); + + if (s_EditorCache.ContainsKey(clip)) + { + var editorClip = s_EditorCache[clip]; + if (editorClip != null) + return editorClip; + } + + var editor = ScriptableObject.CreateInstance(); + editor.hideFlags |= HideFlags.HideInHierarchy | HideFlags.DontSaveInEditor; + editor.lastHash = -1; + editor.clip = clip; + s_EditorCache[clip] = editor; + + return editor; + } + + public static void RemoveEditorClip(TimelineClip clip) + { + if (clip == null) + return; + + if (s_EditorCache.ContainsKey(clip)) + { + var obj = s_EditorCache[clip]; + if (obj != null) + UnityObject.DestroyImmediate(obj); + s_EditorCache.Remove(clip); + } + } + + public static bool Contains(TimelineClip clip) + { + return clip != null && s_EditorCache.ContainsKey(clip); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/EditorClipFactory.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/EditorClipFactory.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..3681c42af6678f7946cb5be01c2711d995647b31 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/EditorClipFactory.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f6ba30c492ac73742bc0cfee6817045a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/GroupTrackInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/GroupTrackInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..5791e511c81ef84f216b0051e893de3e9765ade7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/GroupTrackInspector.cs @@ -0,0 +1,107 @@ +//#define PERF_PROFILE + +using System.Linq; +using UnityEditorInternal; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [CustomEditor(typeof(GroupTrack)), CanEditMultipleObjects] + class GroupTrackInspector : TrackAssetInspector + { + static class Styles + { + public static readonly GUIContent GroupSubTrackHeaderName = EditorGUIUtility.TrTextContent("Name"); + public static readonly GUIContent GroupSubTrackHeaderType = EditorGUIUtility.TrTextContent("Type"); + public static readonly GUIContent GroupSubTrackHeaderDuration = EditorGUIUtility.TrTextContent("Duration"); + public static readonly GUIContent GroupSubTrackHeaderFrames = EditorGUIUtility.TrTextContent("Frames"); + public static readonly GUIContent GroupInvalidTrack = EditorGUIUtility.TrTextContent("Invalid Track"); + } + + ReorderableList m_SubTracks; + + public override void OnInspectorGUI() + { + foreach (var group in targets) + { + var groupTrack = group as GroupTrack; + if (groupTrack == null) return; + + var childrenTracks = groupTrack.GetChildTracks(); + var groupTrackName = groupTrack.name; + + GUILayout.Label(childrenTracks.Count() > 0 + ? groupTrackName + " (" + childrenTracks.Count() + ")" + : groupTrackName, EditorStyles.boldLabel); + GUILayout.Space(3.0f); + + // the subTrackObjects is used because it's the internal list + m_SubTracks.list = groupTrack.subTracksObjects; + m_SubTracks.DoLayoutList(); + m_SubTracks.index = -1; + } + } + + public override void OnEnable() + { + base.OnEnable(); + + m_SubTracks = new ReorderableList(new string[] {}, typeof(string), false, true, false, false) + { + drawElementCallback = OnDrawSubTrack, + drawHeaderCallback = OnDrawHeader, + showDefaultBackground = true, + index = 0, + elementHeight = 20 + }; + } + + static void OnDrawHeader(Rect rect) + { + int sections = 4; + float sectionWidth = rect.width / sections; + + rect.width = sectionWidth; + GUI.Label(rect, Styles.GroupSubTrackHeaderName, EditorStyles.label); + rect.x += sectionWidth; + GUI.Label(rect, Styles.GroupSubTrackHeaderType, EditorStyles.label); + rect.x += sectionWidth; + GUI.Label(rect, Styles.GroupSubTrackHeaderDuration, EditorStyles.label); + rect.x += sectionWidth; + GUI.Label(rect, Styles.GroupSubTrackHeaderFrames, EditorStyles.label); + } + + void OnDrawSubTrack(Rect rect, int index, bool selected, bool focused) + { + int sections = 4; + float sectionWidth = rect.width / sections; + + var childrenTrack = m_SubTracks.list[index] as TrackAsset; + if (childrenTrack == null) + { + object o = m_SubTracks.list[index]; + rect.width = sectionWidth; + if (o != null) // track is loaded, but has broken script + { + string name = ((UnityEngine.Object)m_SubTracks.list[index]).name; + GUI.Label(rect, name, EditorStyles.label); + } + rect.x += sectionWidth; + using (new GUIColorOverride(DirectorStyles.kClipErrorColor)) + GUI.Label(rect, Styles.GroupInvalidTrack.text, EditorStyles.label); + return; + } + + rect.width = sectionWidth; + GUI.Label(rect, childrenTrack.name, EditorStyles.label); + rect.x += sectionWidth; + GUI.Label(rect, childrenTrack.GetType().Name, EditorStyles.label); + rect.x += sectionWidth; + GUI.Label(rect, childrenTrack.duration.ToString(), EditorStyles.label); + rect.x += sectionWidth; + double exactFrames = TimeUtility.ToExactFrames(childrenTrack.duration, TimelineWindow.instance.state.referenceSequence.frameRate); + GUI.Label(rect, exactFrames.ToString(), EditorStyles.label); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/GroupTrackInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/GroupTrackInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2730aef4cbba90d10ba5328aa436efd3344bea19 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/GroupTrackInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 41dcdc094b311464c8d6cb614548d89b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/MarkerInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/MarkerInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..dcef35ecb4d3883468f33ce08022031ef6062027 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/MarkerInspector.cs @@ -0,0 +1,69 @@ +using System; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [CustomEditor(typeof(Marker), true)] + [CanEditMultipleObjects] + class MarkerInspector : BasicAssetInspector + { + static class Styles + { + public static readonly string MultipleMarkerSelectionTitle = L10n.Tr("{0} Markers"); + public static readonly string UndoCommand = L10n.Tr("Rename marker"); + } + + internal override bool IsEnabled() + { + if (!TimelineUtility.IsCurrentSequenceValid() || IsCurrentSequenceReadOnly()) + return false; + var marker = target as Marker; + if (marker != null) + { + if (!marker.parent.GetShowMarkers()) + return false; + } + return base.IsEnabled(); + } + + internal override void OnHeaderTitleGUI(Rect titleRect, string header) + { + if (targets.Length > 1) + { + var multiSelectTitle = string.Format(Styles.MultipleMarkerSelectionTitle, targets.Length); + base.OnHeaderTitleGUI(titleRect, multiSelectTitle); + return; + } + + var marker = target as Marker; + if (marker != null) + { + if (marker.parent.GetShowMarkers() && TimelineUtility.IsCurrentSequenceValid() && !IsCurrentSequenceReadOnly()) + { + EditorGUI.BeginChangeCheck(); + var newName = EditorGUI.DelayedTextField(titleRect, marker.name); + if (EditorGUI.EndChangeCheck()) + { + UndoExtensions.RegisterMarker(marker, Styles.UndoCommand); + marker.name = newName; + } + } + else + { + base.OnHeaderTitleGUI(titleRect, marker.name); + } + } + else + { + var typeName = TypeUtility.GetDisplayName(target.GetType()); + EditorGUILayout.LabelField(typeName); + } + } + + static bool IsCurrentSequenceReadOnly() + { + return TimelineWindow.instance.state.editSequence.isReadOnly; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/MarkerInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/MarkerInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..9f6e901d09b03a44a91b0d7df602aac9de142e9a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/MarkerInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fb461734117c80c43ab595d699f801eb +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimeFieldDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimeFieldDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..622f5b48254715130886eab8f037b64e4c11baba --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimeFieldDrawer.cs @@ -0,0 +1,69 @@ +using System; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [CustomPropertyDrawer(typeof(TimeFieldAttribute), true)] + class TimeFieldDrawer : PropertyDrawer + { + static WindowState state + { + get { return TimelineWindow.instance != null ? TimelineWindow.instance.state : null; } + } + + static float currentFrameRate + { + get { return state != null ? TimelineWindow.instance.state.referenceSequence.frameRate : 0.0f; } + } + + public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) + { + if (property.propertyType != SerializedPropertyType.Float) + { + GUILayout.Label("TimeField only works on floating point types"); + return; + } + + var timeFieldAttribute = attribute as TimeFieldAttribute; + if (timeFieldAttribute == null) + return; + + var rect = EditorGUILayout.s_LastRect; + EditorGUI.BeginChangeCheck(); + + if (timeFieldAttribute.useEditMode == TimeFieldAttribute.UseEditMode.ApplyEditMode) + TimeFieldWithEditMode(rect, property, label); + else + TimeField(rect, property, label); + + if (EditorGUI.EndChangeCheck()) + { + if (state != null) + state.Refresh(); + } + } + + static void TimeField(Rect rect, SerializedProperty property, GUIContent label) + { + var evt1 = InputEvent.None; + TimelineInspectorUtility.TimeField(rect, property, label, false, currentFrameRate, 0, float.MaxValue, ref evt1); + } + + static void TimeFieldWithEditMode(Rect rect, SerializedProperty property, GUIContent label) + { + double minStartTime; + if (property.hasMultipleDifferentValues) + minStartTime = SelectionManager.SelectedItems().Min(i => i.start); + else + minStartTime = property.doubleValue; + + var evt = InputEvent.None; + var newValue = TimelineInspectorUtility.TimeField( + rect, label, minStartTime, false, property.hasMultipleDifferentValues, currentFrameRate, 0.0, float.MaxValue, ref evt); + + EditMode.inputHandler.ProcessMove(evt, newValue); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimeFieldDrawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimeFieldDrawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..89749e8bc9d53855395763329f440ab52c6a38fe --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimeFieldDrawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b0c73ea1c5ff95e43806e9002c155070 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineAssetInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineAssetInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..b83e01f6ecd4369d648125a8f25f43319b80a9bd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineAssetInspector.cs @@ -0,0 +1,116 @@ +using System; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + [CustomEditor(typeof(TimelineAsset)), CanEditMultipleObjects] + class TimelineAssetInspector : Editor + { + const int k_MinWidth = 140; + + static class Styles + { + public static readonly GUIContent FrameRate = EditorGUIUtility.TrTextContent("Frame Rate", "The frame rate at which this sequence updates"); + public static readonly GUIContent DurationMode = EditorGUIUtility.TrTextContent("Duration Mode", "Specified how the duration of the sequence is calculated"); + public static readonly GUIContent Duration = EditorGUIUtility.TrTextContent("Duration", "The length of the sequence"); + public static readonly GUIContent HeaderTitleMultiselection = EditorGUIUtility.TrTextContent("Timeline Assets"); + public static readonly GUIContent IgnorePreviewWarning = EditorGUIUtility.TrTextContent("When ignoring preview, the Timeline window will modify the scene when this timeline is opened."); + public static readonly GUIContent ScenePreviewLabel = EditorGUIUtility.TrTextContent("Scene Preview"); + } + + SerializedProperty m_FrameRateProperty; + SerializedProperty m_DurationModeProperty; + SerializedProperty m_FixedDurationProperty; + SerializedProperty m_ScenePreviewProperty; + + void InitializeProperties() + { + var editorSettings = serializedObject.FindProperty("m_EditorSettings"); + m_FrameRateProperty = editorSettings.FindPropertyRelative("m_Framerate"); + m_DurationModeProperty = serializedObject.FindProperty("m_DurationMode"); + m_FixedDurationProperty = serializedObject.FindProperty("m_FixedDuration"); + m_ScenePreviewProperty = editorSettings.FindPropertyRelative("m_ScenePreview"); + } + + public void OnEnable() + { + InitializeProperties(); + } + + internal override bool IsEnabled() + { + return !FileUtil.HasReadOnly(targets) && base.IsEnabled(); + } + + protected override void OnHeaderGUI() + { + string headerTitle; + if (targets.Length == 1) + headerTitle = target.name; + else + headerTitle = targets.Length + " " + Styles.HeaderTitleMultiselection.text; + + DrawHeaderGUI(this, headerTitle, 0); + } + + public override void OnInspectorGUI() + { + serializedObject.Update(); + + EditorGUI.BeginChangeCheck(); + + EditorGUILayout.PropertyField(m_FrameRateProperty, Styles.FrameRate, GUILayout.MinWidth(k_MinWidth)); + var frameRate = m_FrameRateProperty.doubleValue; + + EditorGUILayout.PropertyField(m_DurationModeProperty, Styles.DurationMode, GUILayout.MinWidth(k_MinWidth)); + + var durationMode = (TimelineAsset.DurationMode)m_DurationModeProperty.enumValueIndex; + var inputEvent = InputEvent.None; + if (durationMode == TimelineAsset.DurationMode.FixedLength) + TimelineInspectorUtility.TimeField(m_FixedDurationProperty, Styles.Duration, false, frameRate, double.Epsilon, TimelineClip.kMaxTimeValue * 2, ref inputEvent); + else + { + var isMixed = targets.Length > 1; + TimelineInspectorUtility.TimeField(Styles.Duration, ((TimelineAsset)target).duration, true, isMixed, frameRate, double.MinValue, double.MaxValue, ref inputEvent); + } + + DrawIgnorePreviewProperty(); + + var changed = EditorGUI.EndChangeCheck(); + serializedObject.ApplyModifiedProperties(); + if (changed) + TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw); + } + + void DrawIgnorePreviewProperty() + { + EditorGUI.BeginChangeCheck(); + { + EditorGUILayout.PropertyField(m_ScenePreviewProperty, Styles.ScenePreviewLabel, GUILayout.MinWidth(k_MinWidth)); + } + var changed = EditorGUI.EndChangeCheck(); + + if (changed && TimelineWindow.instance && TimelineWindow.instance.state != null && ContainsMasterAsset(targets)) + ResetWindowState(TimelineWindow.instance.state); + + if (!m_ScenePreviewProperty.boolValue || m_ScenePreviewProperty.hasMultipleDifferentValues) + EditorGUILayout.HelpBox(Styles.IgnorePreviewWarning.text, MessageType.Warning); + } + + static void ResetWindowState(WindowState state) + { + state.Reset(); + state.Stop(); + state.masterSequence.viewModel.windowTime = 0.0; + if (state.masterSequence.director != null) state.masterSequence.director.time = 0.0; + } + + static bool ContainsMasterAsset(Object[] asset) + { + return asset != null && asset.Any(tl => tl == TimelineWindow.instance.state.masterSequence.asset); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineAssetInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineAssetInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1ba062080d5ea2faf4aa23cd7a7585c14d3615fc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineAssetInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e00a5dea786950546a21b0e2d817e466 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineInspectorUtility.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineInspectorUtility.cs new file mode 100644 index 0000000000000000000000000000000000000000..e54f839e990ed4a46c0c5f88a59b83e28c8b9de7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineInspectorUtility.cs @@ -0,0 +1,346 @@ +using System; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [Flags] + enum InputEvent + { + None = 0, + DragEnter = 1, + DragExit = 2, + Drag = 4, + KeyboardInput = 8 + } + + static class InputEventMethods + { + public static bool InputHasBegun(this InputEvent evt) + { + return evt == InputEvent.DragEnter || evt == InputEvent.KeyboardInput; + } + } + + static class TimelineInspectorUtility + { + internal static class Styles + { + public static readonly GUIContent SecondsPrefix = EditorGUIUtility.TrTextContent("s", "Seconds"); + public static readonly GUIContent FramesPrefix = EditorGUIUtility.TrTextContent("f", "Frames"); + } + + public static void TimeField(SerializedProperty property, GUIContent label, bool readOnly, double frameRate, double minValue, double maxValue, ref InputEvent inputEvent) + { + var rect = EditorGUILayout.GetControlRect(); + TimeField(rect, property, label, readOnly, frameRate, minValue, maxValue, ref inputEvent); + } + + // Display Time related properties in frames and seconds + public static void TimeField(Rect rect, SerializedProperty property, GUIContent label, bool readOnly, double frameRate, double minValue, double maxValue, ref InputEvent inputEvent) + { + using (var propertyScope = new PropertyScope(rect, label, property)) + { + GUIContent title = propertyScope.content; + rect = EditorGUI.PrefixLabel(rect, title); + + using (new IndentLevelScope(0)) + using (new LabelWidthScope((int)EditorGUI.kMiniLabelW)) + using (new GUIMixedValueScope(property.hasMultipleDifferentValues)) + { + var secondsRect = new Rect(rect.xMin, rect.yMin, rect.width / 2 - EditorGUI.kSpacingSubLabel, rect.height); + var framesRect = new Rect(rect.xMin + rect.width / 2, rect.yMin, rect.width / 2, rect.height); + + if (readOnly) + { + EditorGUI.FloatField(secondsRect, Styles.SecondsPrefix, (float)property.doubleValue, EditorStyles.label); + } + else + { + EditorGUI.BeginChangeCheck(); + DelayedAndDraggableDoubleField(secondsRect, Styles.SecondsPrefix, property, ref inputEvent); + if (EditorGUI.EndChangeCheck()) + { + property.doubleValue = Clamp(property.doubleValue, minValue, maxValue); + } + } + + if (frameRate > TimeUtility.kTimeEpsilon) + { + EditorGUI.BeginChangeCheck(); + + double time = property.doubleValue; + int frames = TimeUtility.ToFrames(time, frameRate); + double exactFrames = TimeUtility.ToExactFrames(time, frameRate); + bool useIntField = TimeUtility.OnFrameBoundary(time, frameRate); + + if (readOnly) + { + if (useIntField) + EditorGUI.IntField(framesRect, Styles.FramesPrefix, frames, EditorStyles.label); + else + EditorGUI.DoubleField(framesRect, Styles.FramesPrefix, exactFrames, EditorStyles.label); + } + else + { + if (useIntField) + { + int newFrames = DelayedAndDraggableIntField(framesRect, Styles.FramesPrefix, frames, ref inputEvent); + time = Math.Max(0, TimeUtility.FromFrames(newFrames, frameRate)); + } + else + { + double newExactFrames = DelayedAndDraggableDoubleField(framesRect, Styles.FramesPrefix, exactFrames, ref inputEvent); + time = Math.Max(0, TimeUtility.FromFrames((int)Math.Floor(newExactFrames), frameRate)); + } + } + + if (EditorGUI.EndChangeCheck()) + { + property.doubleValue = Clamp(time, minValue, maxValue); + } + } + } + } + } + + public static double TimeFieldUsingTimeReference( + GUIContent label, double time, bool readOnly, bool showMixed, double frameRate, double minValue, + double maxValue, ref InputEvent inputEvent) + { + var state = TimelineWindow.instance.state; + var needsTimeConversion = state != null && state.timeReferenceMode == TimeReferenceMode.Global; + + if (needsTimeConversion) + time = state.editSequence.ToGlobalTime(time); + + var t = TimeField(label, time, readOnly, showMixed, frameRate, minValue, maxValue, ref inputEvent); + + if (needsTimeConversion) + t = state.editSequence.ToLocalTime(t); + + return t; + } + + public static double DurationFieldUsingTimeReference( + GUIContent label, double start, double end, bool readOnly, bool showMixed, double frameRate, + double minValue, double maxValue, ref InputEvent inputEvent) + { + var state = TimelineWindow.instance.state; + var needsTimeConversion = state != null && state.timeReferenceMode == TimeReferenceMode.Global; + + if (needsTimeConversion) + { + start = state.editSequence.ToGlobalTime(start); + end = state.editSequence.ToGlobalTime(end); + } + + var duration = end - start; + + var t = TimeField(label, duration, readOnly, showMixed, frameRate, minValue, maxValue, ref inputEvent); + + end = start + t; + + if (needsTimeConversion) + { + start = state.editSequence.ToLocalTime(start); + end = state.editSequence.ToLocalTime(end); + } + + return end - start; + } + + public static double TimeField(Rect rect, GUIContent label, double time, bool readOnly, bool showMixed, double frameRate, double minValue, double maxValue, ref InputEvent inputEvent) + { + using (new HorizontalScope(label, GUIStyle.none)) + { + rect = EditorGUI.PrefixLabel(rect, label); + + using (new IndentLevelScope(0)) + using (new LabelWidthScope((int)EditorGUI.kMiniLabelW)) + using (new GUIMixedValueScope(showMixed)) + { + var secondsRect = new Rect(rect.xMin, rect.yMin, rect.width / 2 - EditorGUI.kSpacingSubLabel, rect.height); + var framesRect = new Rect(rect.xMin + rect.width / 2, rect.yMin, rect.width / 2, rect.height); + + if (readOnly) + { + EditorGUI.FloatField(secondsRect, Styles.SecondsPrefix, (float)time, EditorStyles.label); + } + else + { + time = DelayedAndDraggableDoubleField(secondsRect, Styles.SecondsPrefix, time, ref inputEvent); + } + + if (frameRate > TimeUtility.kTimeEpsilon) + { + int frames = TimeUtility.ToFrames(time, frameRate); + double exactFrames = TimeUtility.ToExactFrames(time, frameRate); + bool useIntField = TimeUtility.OnFrameBoundary(time, frameRate); + if (readOnly) + { + if (useIntField) + EditorGUI.IntField(framesRect, Styles.FramesPrefix, frames, EditorStyles.label); + else + EditorGUI.FloatField(framesRect, Styles.FramesPrefix, (float)exactFrames, EditorStyles.label); + } + else + { + double newTime; + EditorGUI.BeginChangeCheck(); + if (useIntField) + { + int newFrames = DelayedAndDraggableIntField(framesRect, Styles.FramesPrefix, frames, ref inputEvent); + newTime = Math.Max(0, TimeUtility.FromFrames(newFrames, frameRate)); + } + else + { + double newExactFrames = DelayedAndDraggableDoubleField(framesRect, Styles.FramesPrefix, exactFrames, ref inputEvent); + newTime = Math.Max(0, TimeUtility.FromFrames((int)Math.Floor(newExactFrames), frameRate)); + } + + if (EditorGUI.EndChangeCheck()) + { + time = newTime; + } + } + } + } + } + + return Clamp(time, minValue, maxValue); + } + + public static double TimeField(GUIContent label, double time, bool readOnly, bool showMixed, double frameRate, double minValue, double maxValue, ref InputEvent inputEvent) + { + var rect = EditorGUILayout.GetControlRect(); + return TimeField(rect, label, time, readOnly, showMixed, frameRate, minValue, maxValue, ref inputEvent); + } + + static InputEvent InputEventType(Rect rect, int id) + { + var evt = Event.current; + switch (evt.GetTypeForControl(id)) + { + case EventType.MouseDown: + if (rect.Contains(evt.mousePosition) && evt.button == 0) + { + return InputEvent.DragEnter; + } + break; + case EventType.MouseUp: + if (GUIUtility.hotControl == id) + { + return InputEvent.DragExit; + } + break; + case EventType.MouseDrag: + if (GUIUtility.hotControl == id) + { + return InputEvent.Drag; + } + break; + case EventType.KeyDown: + if (GUIUtility.hotControl == id && evt.keyCode == KeyCode.Escape) + { + return InputEvent.DragExit; + } + break; + } + return InputEvent.None; + } + + static double DelayedAndDraggableDoubleField(Rect rect, GUIContent label, double value, ref InputEvent inputEvent, double dragSensitivity) + { + var id = GUIUtility.GetControlID(FocusType.Keyboard); + var fieldRect = EditorGUI.PrefixLabel(rect, id, label); + rect.xMax = fieldRect.x; + + double refValue = value; + long dummy = 0; + + inputEvent |= InputEventType(rect, id); + + EditorGUI.DragNumberValue(rect, id, true, ref refValue, ref dummy, dragSensitivity); + + EditorGUI.BeginChangeCheck(); + var result = EditorGUI.DelayedDoubleFieldInternal(fieldRect, GUIContent.none, refValue, EditorStyles.numberField); + if (EditorGUI.EndChangeCheck()) + inputEvent |= InputEvent.KeyboardInput; + + return result; + } + + static int DelayedAndDraggableIntField(Rect rect, GUIContent label, int value, ref InputEvent inputEvent, long dragSensitivity) + { + var id = GUIUtility.GetControlID(FocusType.Keyboard); + var fieldRect = EditorGUI.PrefixLabel(rect, id, label); + rect.xMax = fieldRect.x; + + double dummy = 0.0; + long refValue = value; + + inputEvent |= InputEventType(rect, id); + + EditorGUI.DragNumberValue(rect, id, false, ref dummy, ref refValue, dragSensitivity); + + EditorGUI.BeginChangeCheck(); + var result = EditorGUI.DelayedIntFieldInternal(fieldRect, GUIContent.none, (int)refValue, EditorStyles.numberField); + if (EditorGUI.EndChangeCheck()) + inputEvent |= InputEvent.KeyboardInput; + + return result; + } + + internal static double DelayedAndDraggableDoubleField(GUIContent label, double value, ref InputEvent action, double dragSensitivity) + { + var r = EditorGUILayout.s_LastRect = EditorGUILayout.GetControlRect(false, EditorGUI.kSingleLineHeight); + return DelayedAndDraggableDoubleField(r, label, value, ref action, dragSensitivity); + } + + static void DelayedAndDraggableDoubleField(Rect rect, GUIContent label, SerializedProperty property, ref InputEvent inputEvent) + { + EditorGUI.BeginChangeCheck(); + var newValue = DelayedAndDraggableDoubleField(rect, label, property.doubleValue, ref inputEvent); + if (EditorGUI.EndChangeCheck()) + property.doubleValue = newValue; + } + + static double DelayedAndDraggableDoubleField(Rect rect, GUIContent label, double value, ref InputEvent inputEvent) + { + var dragSensitivity = NumericFieldDraggerUtility.CalculateFloatDragSensitivity(value); + return DelayedAndDraggableDoubleField(rect, label, value, ref inputEvent, dragSensitivity); + } + + static int DelayedAndDraggableIntField(Rect rect, GUIContent label, int value, ref InputEvent inputEvent) + { + var dragSensitivity = NumericFieldDraggerUtility.CalculateIntDragSensitivity(value); + return DelayedAndDraggableIntField(rect, label, value, ref inputEvent, dragSensitivity); + } + + internal static T Clamp(this T val, T min, T max) where T : IComparable + { + if (val.CompareTo(min) < 0) return min; + if (val.CompareTo(max) > 0) return max; + return val; + } + + public static Editor GetInspectorForObjects(UnityEngine.Object[] objects) + { + // create cached editor throws on assembly reload... + try + { + if (objects.Any(x => x != null)) + { + var director = TimelineWindow.instance.state.editSequence.director; + return Editor.CreateEditorWithContext(objects, director, null); + } + } + catch (Exception) + {} + + return null; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineInspectorUtility.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineInspectorUtility.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..808a29d02739a7d9f4c8b91d81bfedc48d158015 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineInspectorUtility.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3387717991705ce4e8ef033a0e543a06 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelinePreferences.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelinePreferences.cs new file mode 100644 index 0000000000000000000000000000000000000000..f902405c3bc97dfe7d1d52f5b9f014edea2725ba --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelinePreferences.cs @@ -0,0 +1,158 @@ +using System.Collections.Generic; +using UnityEditor; +using UnityEditor.Timeline; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.UIElements; + +/// +/// Store the editor preferences for Timeline. +/// +[FilePath("TimelinePreferences.asset", FilePathAttribute.Location.PreferencesFolder)] +public class TimelinePreferences : ScriptableSingleton +{ + /// + /// Define the time unit for the timeline window. + /// true : frame unit. + /// false : seconds unit. + /// + [SerializeField] + public bool timeUnitInFrame = true; + /// + /// Draw the waveforms for all audio clips. + /// + [SerializeField] + public bool showAudioWaveform = true; + + /// + /// Allow the users to hear audio while scrubbing on audio clip. + /// + [SerializeField] + bool m_AudioScrubbing; + + /// + /// Enables audio scrubbing when moving the playhead. + /// + public bool audioScrubbing + { + get { return m_AudioScrubbing; } + set + { + if (m_AudioScrubbing != value) + { + m_AudioScrubbing = value; + TimelinePlayable.muteAudioScrubbing = !value; + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + } + } + + /// + /// Enable Snap to Frame to manipulate clips and align them on frames. + /// + [SerializeField] + public bool snapToFrame = true; + /// + /// Enable the ability to snap clips on the edge of another clip. + /// + [SerializeField] + public bool edgeSnap = true; + /// + /// Behavior of the timeline window during playback. + /// + [SerializeField] + public PlaybackScrollMode playbackScrollMode = PlaybackScrollMode.None; + + void OnDisable() + { + Save(); + } + + /// + /// Save the timeline preferences settings file. + /// + public void Save() + { + Save(true); + } + + internal SerializedObject GetSerializedObject() + { + return new SerializedObject(this); + } +} + +class TimelinePreferencesProvider : SettingsProvider +{ + SerializedObject m_SerializedObject; + SerializedProperty m_ShowAudioWaveform; + SerializedProperty m_TimeUnitInFrame; + SerializedProperty m_SnapToFrame; + SerializedProperty m_EdgeSnap; + SerializedProperty m_PlaybackScrollMode; + + static string[] timeUnitsList = new string[] + { + "Seconds", + "Frames" + }; + + private class Styles + { + public static readonly GUIContent TimeUnitLabel = EditorGUIUtility.TrTextContent("Time Unit", "Define the time unit for the timeline window (Frames or Seconds)."); + public static readonly GUIContent ShowAudioWaveformLabel = EditorGUIUtility.TrTextContent("Show Audio Waveforms", "Draw the waveforms for all audio clips."); + public static readonly GUIContent AudioScrubbingLabel = EditorGUIUtility.TrTextContent("Allow Audio Scrubbing", "Allow the users to hear audio while scrubbing on audio clip."); + public static readonly GUIContent SnapToFrameLabel = EditorGUIUtility.TrTextContent("Snap To Frame", "Enable Snap to Frame to manipulate clips and align them on frames."); + public static readonly GUIContent EdgeSnapLabel = EditorGUIUtility.TrTextContent("Edge Snap", "Enable the ability to snap clips on the edge of another clip."); + public static readonly GUIContent PlaybackScrollModeLabel = EditorGUIUtility.TrTextContent("Playback Scrolling Mode", "Define scrolling behavior during playback."); + public static readonly GUIContent EditorSettingLabel = EditorGUIUtility.TrTextContent("Timeline Editor Settings", ""); + } + + public TimelinePreferencesProvider(string path, SettingsScope scopes, IEnumerable keywords = null) + : base(path, scopes, keywords) + { + } + + public override void OnActivate(string searchContext, VisualElement rootElement) + { + TimelinePreferences.instance.Save(); + m_SerializedObject = TimelinePreferences.instance.GetSerializedObject(); + m_ShowAudioWaveform = m_SerializedObject.FindProperty("showAudioWaveform"); + m_TimeUnitInFrame = m_SerializedObject.FindProperty("timeUnitInFrame"); + m_SnapToFrame = m_SerializedObject.FindProperty("snapToFrame"); + m_EdgeSnap = m_SerializedObject.FindProperty("edgeSnap"); + m_PlaybackScrollMode = m_SerializedObject.FindProperty("playbackScrollMode"); + } + + public override void OnGUI(string searchContext) + { + m_SerializedObject.Update(); + EditorGUI.BeginChangeCheck(); + using (new SettingsWindow.GUIScope()) + { + EditorGUILayout.LabelField(Styles.EditorSettingLabel, EditorStyles.boldLabel); + + int timeUnitIdx = EditorGUILayout.Popup(Styles.TimeUnitLabel, m_TimeUnitInFrame.boolValue ? 1 : 0, timeUnitsList); + m_TimeUnitInFrame.boolValue = timeUnitIdx == 1; + + m_PlaybackScrollMode.enumValueIndex = EditorGUILayout.Popup(Styles.PlaybackScrollModeLabel, m_PlaybackScrollMode.enumValueIndex, m_PlaybackScrollMode.enumNames); + m_ShowAudioWaveform.boolValue = EditorGUILayout.Toggle(Styles.ShowAudioWaveformLabel, m_ShowAudioWaveform.boolValue); + TimelinePreferences.instance.audioScrubbing = EditorGUILayout.Toggle(Styles.AudioScrubbingLabel, TimelinePreferences.instance.audioScrubbing); + m_SnapToFrame.boolValue = EditorGUILayout.Toggle(Styles.SnapToFrameLabel, m_SnapToFrame.boolValue); + m_EdgeSnap.boolValue = EditorGUILayout.Toggle(Styles.EdgeSnapLabel, m_EdgeSnap.boolValue); + } + if (EditorGUI.EndChangeCheck()) + { + m_SerializedObject.ApplyModifiedProperties(); + TimelinePreferences.instance.Save(); + TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw); + } + } + + [SettingsProvider] + public static SettingsProvider CreateTimelineProjectSettingProvider() + { + var provider = new TimelinePreferencesProvider("Preferences/Timeline", SettingsScope.User, GetSearchKeywordsFromGUIContentProperties()); + return provider; + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelinePreferences.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelinePreferences.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..41a884c3620cba4bd4c15836890fd9ebe0f5885b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelinePreferences.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 227613ec5b3943443a284e30a6d6b91e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineProjectSettings.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineProjectSettings.cs new file mode 100644 index 0000000000000000000000000000000000000000..db190e3ae2e5ac98da7c936acf15e01fe7ba01b7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineProjectSettings.cs @@ -0,0 +1,126 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEditor; +using UnityEngine.Timeline; +using UnityEngine.UIElements; + +/// +/// Store the settings for Timeline that will be stored with the Unity Project. +/// +[FilePath("ProjectSettings/TimelineSettings.asset", FilePathAttribute.Location.ProjectFolder)] +public class TimelineProjectSettings : ScriptableSingleton +{ + /// + /// Define the default framerate when a Timeline asset is created. + /// + [SerializeField] + public float assetDefaultFramerate = TimelineAsset.EditorSettings.kDefaultFps; + + internal static string[] framerateLabels = new string[] + { + "Film (24)", + "PAL (25)", + "NTSC (29.97)", + "Film (30)", + "Film (50)", + "Film (60)", + "Custom" + }; + + internal static float[] framerateValues = new float[] + { + 24.0f, + 25.0f, + 29.97f, + 30.0f, + 50.0f, + 60.0f + }; + + void OnDisable() + { + Save(); + } + + /// + /// Save the timeline project settings file in the project directory. + /// + public void Save() + { + Save(true); + } + + internal SerializedObject GetSerializedObject() + { + return new SerializedObject(this); + } +} + +class TimelineProjectSettingsProvider : SettingsProvider +{ + SerializedObject m_SerializedObject; + SerializedProperty m_Framerate; + + bool m_customFramerate; + + private class Styles + { + public static readonly GUIContent DefaultFramerateLabel = EditorGUIUtility.TrTextContent("Default Framerate", "Framerate value used for new Timeline Assets."); + public static readonly GUIContent CustomFramerateLabel = EditorGUIUtility.TrTextContent("Custom Framerate", "Custom framerate value used for new Timeline Assets."); + public static readonly GUIContent TimelineAssetLabel = EditorGUIUtility.TrTextContent("Timeline Asset", ""); + } + + public TimelineProjectSettingsProvider(string path, SettingsScope scopes, IEnumerable keywords = null) + : base(path, scopes, keywords) {} + + public override void OnActivate(string searchContext, VisualElement rootElement) + { + TimelineProjectSettings.instance.Save(); + m_SerializedObject = TimelineProjectSettings.instance.GetSerializedObject(); + m_Framerate = m_SerializedObject.FindProperty("assetDefaultFramerate"); + } + + public override void OnGUI(string searchContext) + { + using (new SettingsWindow.GUIScope()) + { + m_SerializedObject.Update(); + EditorGUI.BeginChangeCheck(); + EditorGUILayout.LabelField(Styles.TimelineAssetLabel , EditorStyles.boldLabel); + + int framerateIdx = Array.IndexOf(TimelineProjectSettings.framerateValues, m_Framerate.floatValue); + if (m_customFramerate || framerateIdx == -1) + { + framerateIdx = TimelineProjectSettings.framerateValues.Length; + } + + framerateIdx = EditorGUILayout.Popup(Styles.DefaultFramerateLabel, framerateIdx, TimelineProjectSettings.framerateLabels); + + if (framerateIdx == TimelineProjectSettings.framerateValues.Length || framerateIdx == -1) + { + m_customFramerate = true; + float newFramerate = EditorGUILayout.FloatField(Styles.CustomFramerateLabel, m_Framerate.floatValue); + m_Framerate.floatValue = TimelineAsset.GetValidFramerate(newFramerate); + } + else + { + m_customFramerate = false; + m_Framerate.floatValue = TimelineProjectSettings.framerateValues[framerateIdx]; + } + + if (EditorGUI.EndChangeCheck()) + { + m_SerializedObject.ApplyModifiedProperties(); + TimelineProjectSettings.instance.Save(); + } + } + } + + [SettingsProvider] + public static SettingsProvider CreateTimelineProjectSettingProvider() + { + var provider = new TimelineProjectSettingsProvider("Project/Timeline", SettingsScope.Project, GetSearchKeywordsFromGUIContentProperties()); + return provider; + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineProjectSettings.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineProjectSettings.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2c4966193eb16be72914c40359eaedb4bfb5afd8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TimelineProjectSettings.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a287be6c49135cd4f9b2b8666c39d999 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TrackAssetInspector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TrackAssetInspector.cs new file mode 100644 index 0000000000000000000000000000000000000000..91e83e17f3f57936ba1a132091873c1f24392254 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TrackAssetInspector.cs @@ -0,0 +1,203 @@ +//#define PERF_PROFILE + +using System.Linq; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [CustomEditor(typeof(TrackAsset), true, isFallback = true)] + [CanEditMultipleObjects] + class TrackAssetInspector : Editor + { + class TrackCurvesWrapper : ICurvesOwnerInspectorWrapper + { + public ICurvesOwner curvesOwner { get; } + public SerializedObject serializedPlayableAsset { get; } + + public int lastCurveVersion { get; set; } + public double lastEvalTime { get; set; } + + public TrackCurvesWrapper(TrackAsset track) + { + lastCurveVersion = -1; + lastEvalTime = -1; + + if (track != null) + { + curvesOwner = track; + serializedPlayableAsset = new SerializedObject(track); + } + } + + public double ToLocalTime(double time) + { + return time; + } + } + + TrackCurvesWrapper m_TrackCurvesWrapper; + + SerializedProperty m_Name; + bool m_IsBuiltInType; + + Texture m_HeaderIcon; + + + protected TimelineWindow timelineWindow + { + get + { + return TimelineWindow.instance; + } + } + + protected bool IsTrackLocked() + { + if (!TimelineUtility.IsCurrentSequenceValid() || IsCurrentSequenceReadOnly()) + return true; + + return targets.Any(track => ((TrackAsset)track).lockedInHierarchy); + } + + public override void OnInspectorGUI() + { + using (new EditorGUI.DisabledScope(IsTrackLocked())) + { + DrawInspector(); + } + } + + internal override bool IsEnabled() + { + return TimelineUtility.IsCurrentSequenceValid() && !IsCurrentSequenceReadOnly() && base.IsEnabled(); + } + + internal override void OnHeaderTitleGUI(Rect titleRect, string header) + { + serializedObject.Update(); + + var textFieldRect = titleRect; + using (new GUIMixedValueScope(m_Name.hasMultipleDifferentValues)) + { + var seqWindow = TimelineWindow.instance; + + if (IsTrackLocked()) + { + base.OnHeaderTitleGUI(titleRect, m_Name.stringValue); + } + else + { + EditorGUI.BeginChangeCheck(); + string newName = EditorGUI.DelayedTextField(textFieldRect, m_Name.stringValue, EditorStyles.textField); + if (EditorGUI.EndChangeCheck() && !string.IsNullOrEmpty(newName)) + { + for (int c = 0; c < targets.Length; c++) + { + ObjectNames.SetNameSmart(targets[c], newName); + } + + if (seqWindow != null) + seqWindow.Repaint(); + } + + serializedObject.ApplyModifiedProperties(); + } + } + } + + internal override void OnHeaderIconGUI(Rect iconRect) + { + if (TimelineWindow.instance == null) + return; + using (new EditorGUI.DisabledScope(IsTrackLocked())) + { + if (m_HeaderIcon != null) + GUI.Label(iconRect, GUIContent.Temp(m_HeaderIcon)); + } + } + + internal override Rect DrawHeaderHelpAndSettingsGUI(Rect r) + { + using (new EditorGUI.DisabledScope(IsTrackLocked())) + { + var helpSize = EditorStyles.iconButton.CalcSize(EditorGUI.GUIContents.helpIcon); + const int kTopMargin = 5; + + // Show Editor Header Items. + return EditorGUIUtility.DrawEditorHeaderItems(new Rect(r.xMax - helpSize.x, r.y + kTopMargin, helpSize.x, helpSize.y), targets); + } + } + + public virtual void OnEnable() + { + m_IsBuiltInType = target != null && target.GetType().Assembly == typeof(TrackAsset).Assembly; + m_Name = serializedObject.FindProperty("m_Name"); + m_TrackCurvesWrapper = new TrackCurvesWrapper(target as TrackAsset); + m_HeaderIcon = TrackResourceCache.s_DefaultIcon.image; + + // only worry about the first track. if types are different, a different inspector is used. + var track = target as TrackAsset; + if (track != null) + { + var drawer = CustomTimelineEditorCache.GetTrackEditor(track); + UnityEngine.Object binding = null; + var director = m_Context as PlayableDirector; + if (director != null) + binding = director.GetGenericBinding(track); + + var options = drawer.GetTrackOptions(track, binding); + if (options.icon != null) + m_HeaderIcon = options.icon; + else + m_HeaderIcon = TrackResourceCache.GetTrackIcon(track).image; + } + } + + void DrawInspector() + { + if (serializedObject == null) + return; + + CurvesOwnerInspectorHelper.PreparePlayableAsset(m_TrackCurvesWrapper); + serializedObject.Update(); + + using (var changeScope = new EditorGUI.ChangeCheckScope()) + { + DrawTrackProperties(); + + if (changeScope.changed) + { + serializedObject.ApplyModifiedProperties(); + ApplyChanges(); + } + } + } + + protected virtual void DrawTrackProperties() + { + var property = serializedObject.GetIterator(); + var expanded = true; + while (property.NextVisible(expanded)) + { + // Don't draw script field for built-in types + if (m_IsBuiltInType && "m_Script" == property.propertyPath) + continue; + + EditorGUILayout.PropertyField(property, !expanded); + expanded = false; + } + } + + protected virtual void ApplyChanges() + { + TimelineEditor.Refresh(RefreshReason.ContentsModified); + } + + static bool IsCurrentSequenceReadOnly() + { + return TimelineWindow.instance.state.editSequence.isReadOnly; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TrackAssetInspector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TrackAssetInspector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..922b04906601d1e5856fe2d451e87d6585370d4d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/inspectors/TrackAssetInspector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8795e0dd0041d2f44b1fe1959fc9fb53 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/AnimationTrackKeyDataSource.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/AnimationTrackKeyDataSource.cs new file mode 100644 index 0000000000000000000000000000000000000000..38c2f81b490c6f7407d8807dede3eddcbe938e37 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/AnimationTrackKeyDataSource.cs @@ -0,0 +1,25 @@ +using UnityEngine; +using UnityEngine.Timeline; + +// Data sources for key overlays +namespace UnityEditor.Timeline +{ + // Used for key overlays manipulators + class AnimationTrackKeyDataSource : BasePropertyKeyDataSource + { + readonly float m_TrackOffset; + + protected override AnimationClip animationClip { get; } + + public AnimationTrackKeyDataSource(AnimationTrack track) + { + animationClip = track != null ? track.infiniteClip : null; + m_TrackOffset = track != null ? (float)track.infiniteClipTimeOffset : 0.0f; + } + + protected override float TransformKeyTime(float keyTime) + { + return keyTime + m_TrackOffset; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/AnimationTrackKeyDataSource.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/AnimationTrackKeyDataSource.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..3c81758369093c555b49d797bb3a48f1aef034c8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/AnimationTrackKeyDataSource.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a0b56195e00682b4594dfaeef9d5fa78 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Control.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Control.cs new file mode 100644 index 0000000000000000000000000000000000000000..8788058a38623c9110f74fbe07340aecc1309d8e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Control.cs @@ -0,0 +1,28 @@ +using System.Collections.Generic; + +namespace UnityEditor.Timeline +{ + class Control + { + readonly List m_Manipulators = new List(); + + public bool HandleManipulatorsEvents(WindowState state) + { + var isHandled = false; + + foreach (var manipulator in m_Manipulators) + { + isHandled = manipulator.HandleEvent(state); + if (isHandled) + break; + } + + return isHandled; + } + + public void AddManipulator(Manipulator m) + { + m_Manipulators.Add(m); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Control.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Control.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..71c8d33c46062aa3e11c46f06978c23ef057528e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Control.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 077690d334440b044bdd51b26b3e9413 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers.meta new file mode 100644 index 0000000000000000000000000000000000000000..a7ad23a1e967dcfee90de9669e6da479cb0191ba --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: d40a0edbdcdcf9747a420f3bbe0f18db +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/AnimationTrackDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/AnimationTrackDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..0c20febc2ca77bc86b246f05c651fe2de902ce9c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/AnimationTrackDrawer.cs @@ -0,0 +1,89 @@ +using System; +using JetBrains.Annotations; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + [CustomTrackDrawer(typeof(AnimationTrack)), UsedImplicitly] + class AnimationTrackDrawer : TrackDrawer + { + static class Styles + { + public static readonly GUIContent AvatarMaskActiveTooltip = EditorGUIUtility.TrTextContent(string.Empty, "Enable Avatar Mask"); + public static readonly GUIContent AvatarMaskInactiveTooltip = EditorGUIUtility.TrTextContent(string.Empty, "Disable Avatar Mask"); + } + + public override void DrawTrackHeaderButton(Rect rect, WindowState state) + { + var animTrack = track as AnimationTrack; + if (animTrack == null) return; + + var style = DirectorStyles.Instance.trackAvatarMaskButton; + var tooltip = animTrack.applyAvatarMask ? Styles.AvatarMaskInactiveTooltip : Styles.AvatarMaskActiveTooltip; + + using (var check = new EditorGUI.ChangeCheckScope()) + { + var toggle = GUI.Toggle(rect, animTrack.applyAvatarMask, tooltip, style); + if (check.changed) + { + animTrack.applyAvatarMask = toggle; + if (state != null) + state.rebuildGraph = true; + } + } + } + + public override void DrawRecordingBackground(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state) + { + base.DrawRecordingBackground(trackRect, trackAsset, visibleTime, state); + DrawBorderOfAddedRecordingClip(trackRect, trackAsset, visibleTime, (WindowState)state); + } + + static void DrawBorderOfAddedRecordingClip(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state) + { + if (!state.IsArmedForRecord(trackAsset)) + return; + + AnimationTrack animTrack = trackAsset as AnimationTrack; + if (animTrack == null || !animTrack.inClipMode) + return; + + // make sure there is no clip but we can add one + TimelineClip clip = null; + if (trackAsset.FindRecordingClipAtTime(state.editSequence.time, out clip) || clip != null) + return; + + float yMax = trackRect.yMax; + float yMin = trackRect.yMin; + + double startGap = 0; + double endGap = 0; + + trackAsset.GetGapAtTime(state.editSequence.time, out startGap, out endGap); + if (double.IsInfinity(endGap)) + endGap = visibleTime.y; + + if (startGap > visibleTime.y || endGap < visibleTime.x) + return; + + + startGap = Math.Max(startGap, visibleTime.x); + endGap = Math.Min(endGap, visibleTime.y); + + float xMin = state.TimeToPixel(startGap); + float xMax = state.TimeToPixel(endGap); + + var r = Rect.MinMaxRect(xMin, yMin, xMax, yMax); + ClipDrawer.DrawClipSelectionBorder(r, ClipBorder.Recording(), ClipBlends.kNone); + } + + public override bool HasCustomTrackHeaderButton() + { + var animTrack = track as AnimationTrack; + if (animTrack == null) return false; + + return animTrack != null && animTrack.avatarMask != null; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/AnimationTrackDrawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/AnimationTrackDrawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..20fed76a38183c47a1be730caa6c60e2e0ef195c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/AnimationTrackDrawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: cb281723220c9964094e6c52e0ece792 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/ClipDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/ClipDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..058cb3165b002ad8e0c3d46184a14ea7b4f2396b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/ClipDrawer.cs @@ -0,0 +1,682 @@ +using System; +using UnityEngine.Timeline; +using UnityEngine; +using System.Linq; +using System.Collections.Generic; + +namespace UnityEditor.Timeline +{ + enum BlendKind + { + None, + Ease, + Mix + } + + enum BlendAngle + { + Descending, + Ascending + } + + struct IconData + { + public enum Side { Left = -1, Right = 1 } + + public Texture2D icon; + public Color tint; + + public float width { get { return 16; } } + public float height { get { return 16; } } + + public IconData(Texture2D icon) + { + this.icon = icon; + tint = Color.white; + } + } + + struct ClipBorder + { + public readonly Color color; + public readonly float thickness; + + ClipBorder(Color color, float thickness) + { + this.color = color; + this.thickness = thickness; + } + + const float k_ClipSelectionBorder = 1.0f; + const float k_ClipRecordingBorder = 2.0f; + + public static ClipBorder Recording() + { + return new ClipBorder(DirectorStyles.Instance.customSkin.colorRecordingClipOutline, k_ClipRecordingBorder); + } + + public static ClipBorder Selection() + { + return new ClipBorder(Color.white, k_ClipSelectionBorder); + } + + public static ClipBorder Default() + { + return new ClipBorder(DirectorStyles.Instance.customSkin.clipBorderColor, k_ClipSelectionBorder); + } + } + + struct ClipBlends + { + public readonly BlendKind inKind; + public readonly Rect inRect; + + public readonly BlendKind outKind; + public readonly Rect outRect; + + public ClipBlends(BlendKind inKind, Rect inRect, BlendKind outKind, Rect outRect) + { + this.inKind = inKind; + this.inRect = inRect; + this.outKind = outKind; + this.outRect = outRect; + } + + public static readonly ClipBlends kNone = new ClipBlends(BlendKind.None, Rect.zero, BlendKind.None, Rect.zero); + } + + struct ClipDrawData + { + public TimelineClip clip; // clip being drawn + public Rect targetRect; // rectangle to draw to + public Rect unclippedRect; // the clip's unclipped rect + public Rect clippedRect; // the clip's clipped rect to the visible time area + public Rect clipCenterSection; // clip center section + public string title; // clip title + public bool selected; // is the clip selected + public bool inlineCurvesSelected; // is the inline curve of the clip selected + public double localVisibleStartTime; + public double localVisibleEndTime; + public IconData[] leftIcons; + public IconData[] rightIcons; + public TimelineClip previousClip; + public bool previousClipSelected; + public bool supportsLooping; + public int minLoopIndex; + public List loopRects; + public ClipBlends clipBlends; + public ClipDrawOptions ClipDrawOptions; + public ClipEditor clipEditor; + } + + static class ClipDrawer + { + public static class Styles + { + public static readonly Texture2D iconWarn = EditorGUIUtility.LoadIconRequired("console.warnicon.inactive.sml"); + public static readonly string HoldText = L10n.Tr("HOLD"); + public static readonly Texture2D s_IconNoRecord = EditorGUIUtility.LoadIcon("console.erroricon.sml"); + public static readonly GUIContent s_ClipNotRecorable = EditorGUIUtility.TrTextContent("", "This clip is not recordable"); + public static readonly GUIContent s_ClipNoRecordInBlend = EditorGUIUtility.TrTextContent("", "Recording in blends in prohibited"); + } + + const float k_ClipSwatchLineThickness = 4.0f; + const float k_MinClipWidth = 7.0f; + const float k_ClipInOutMinWidth = 15.0f; + const float k_ClipLoopsMinWidth = 20.0f; + const float k_ClipLabelPadding = 6.0f; + const float k_ClipLabelMinWidth = 10.0f; + const float k_IconsPadding = 1.0f; + const float k_ClipInlineWidth = 1.0f; + + static readonly GUIContent s_TitleContent = new GUIContent(); + static readonly IconData[] k_ClipErrorIcons = { new IconData {icon = Styles.iconWarn, tint = DirectorStyles.kClipErrorColor} }; + static readonly Dictionary s_LoopStringCache = new Dictionary(100); + + // caches the loopstring to avoid allocation from string concats + static string GetLoopString(int loopIndex) + { + string loopString = null; + if (!s_LoopStringCache.TryGetValue(loopIndex, out loopString)) + { + loopString = "L" + loopIndex; + s_LoopStringCache[loopIndex] = loopString; + } + return loopString; + } + + static void DrawLoops(ClipDrawData drawData) + { + if (drawData.loopRects == null || drawData.loopRects.Count == 0) + return; + + var oldColor = GUI.color; + + int loopIndex = drawData.minLoopIndex; + for (int l = 0; l < drawData.loopRects.Count; l++) + { + Rect theRect = drawData.loopRects[l]; + theRect.x -= drawData.unclippedRect.x; + theRect.x += 1; + theRect.width -= 2.0f; + theRect.y = 5.0f; + theRect.height -= 4.0f; + theRect.xMin -= 4f; + + if (theRect.width >= 5f) + { + using (new GUIViewportScope(drawData.clipCenterSection)) + { + GUI.color = new Color(0.0f, 0.0f, 0.0f, 0.2f); + GUI.Label(theRect, GUIContent.none, DirectorStyles.Instance.displayBackground); + + if (theRect.width > 36.0f) + { + var style = DirectorStyles.Instance.fontClipLoop; + GUI.color = new Color(0.0f, 0.0f, 0.0f, 0.3f); + var loopContent = new GUIContent(drawData.supportsLooping ? GetLoopString(loopIndex) : Styles.HoldText); + GUI.Label(theRect, loopContent, style); + } + } + } + + loopIndex++; + + if (!drawData.supportsLooping) + break; + } + + GUI.color = oldColor; + } + + static void DrawClipBorder(ClipDrawData drawData) + { + var animTrack = drawData.clip.parentTrack as AnimationTrack; + var selectionBorder = ClipBorder.Selection(); + + if (TimelineWindow.instance.state.recording && animTrack == null && drawData.clip.parentTrack.IsRecordingToClip(drawData.clip)) + { + DrawClipSelectionBorder(drawData.clipCenterSection, selectionBorder, drawData.clipBlends); + return; + } + + DrawClipDefaultBorder(drawData.clipCenterSection, ClipBorder.Default(), drawData.clipBlends); + + if (drawData.selected) + DrawClipSelectionBorder(drawData.clipCenterSection, selectionBorder, drawData.clipBlends); + + if (drawData.previousClip != null && drawData.previousClipSelected) + { + bool shouldDrawLeftLine = Math.Abs(drawData.previousClip.start - drawData.clip.start) < double.Epsilon; + DrawClipBlendSelectionBorder(drawData.clipCenterSection, selectionBorder, drawData.clipBlends, shouldDrawLeftLine); + } + } + + public static void DrawClipSelectionBorder(Rect clipRect, ClipBorder border, ClipBlends blends) + { + var thickness = border.thickness; + var color = border.color; + var min = clipRect.min; + var max = clipRect.max; + + //Left line + if (blends.inKind == BlendKind.None) + EditorGUI.DrawRect(new Rect(min.x, min.y, thickness, max.y - min.y), color); + else + DrawBlendLine(blends.inRect, blends.inKind == BlendKind.Mix ? BlendAngle.Descending : BlendAngle.Ascending, thickness, color); + + //Right line + if (blends.outKind == BlendKind.None) + EditorGUI.DrawRect(new Rect(max.x - thickness, min.y, thickness, max.y - min.y), color); + else + DrawBlendLine(blends.outRect, BlendAngle.Descending, thickness, color); + + //Top line + var xTop1 = blends.inKind == BlendKind.Mix ? blends.inRect.xMin : min.x; + var xTop2 = max.x; + EditorGUI.DrawRect(new Rect(xTop1, min.y, xTop2 - xTop1, thickness), color); + + //Bottom line + var xBottom1 = blends.inKind == BlendKind.Ease ? blends.inRect.xMin : min.x; + var xBottom2 = blends.outKind == BlendKind.None ? max.x : blends.outRect.xMax; + EditorGUI.DrawRect(new Rect(xBottom1, max.y - thickness, xBottom2 - xBottom1, thickness), color); + } + + static Vector3[] s_BlendLines = new Vector3[4]; + static void DrawBlendLine(Rect rect, BlendAngle blendAngle, float width, Color color) + { + var halfWidth = width / 2.0f; + Vector2 p0, p1; + var inverse = 1.0f; + if (blendAngle == BlendAngle.Descending) + { + p0 = rect.min; + p1 = rect.max; + } + else + { + p0 = new Vector2(rect.xMax, rect.yMin); + p1 = new Vector2(rect.xMin, rect.yMax); + inverse = -1.0f; + } + s_BlendLines[0] = new Vector3(p0.x - halfWidth, p0.y + halfWidth * inverse); + s_BlendLines[1] = new Vector3(p1.x - halfWidth, p1.y + halfWidth * inverse); + s_BlendLines[2] = new Vector3(p1.x + halfWidth, p1.y - halfWidth * inverse); + s_BlendLines[3] = new Vector3(p0.x + halfWidth, p0.y - halfWidth * inverse); + Graphics.DrawPolygonAA(color, s_BlendLines); + } + + static void DrawClipBlendSelectionBorder(Rect clipRect, ClipBorder border, ClipBlends blends, bool shouldLeftLine = false) + { + var color = border.color; + var thickness = border.thickness; + if (blends.inKind == BlendKind.Mix) + { + DrawBlendLine(blends.inRect, BlendAngle.Descending, thickness, color); + var xBottom1 = blends.inRect.xMin; + var xBottom2 = blends.inRect.xMax; + EditorGUI.DrawRect(new Rect(xBottom1, clipRect.max.y - thickness, xBottom2 - xBottom1, thickness), color); + if (shouldLeftLine) + EditorGUI.DrawRect(new Rect(xBottom1, clipRect.min.y, thickness, clipRect.max.y - clipRect.min.y), color); + } + } + + static void DrawClipDefaultBorder(Rect clipRect, ClipBorder border, ClipBlends blends) + { + var color = border.color; + var thickness = border.thickness; + + // Draw vertical lines at the edges of the clip + EditorGUI.DrawRect(new Rect(clipRect.xMin, clipRect.y, thickness, clipRect.height), color); //left + //only draw the right one when no out mix blend + if (blends.outKind != BlendKind.Mix) + EditorGUI.DrawRect(new Rect(clipRect.xMax - thickness, clipRect.y, thickness, clipRect.height), color); //right + //draw a vertical line for the previous clip + if (blends.inKind == BlendKind.Mix) + EditorGUI.DrawRect(new Rect(blends.inRect.xMin, blends.inRect.y, thickness, blends.inRect.height), color); //left + + //Draw blend line + if (blends.inKind == BlendKind.Mix) + DrawBlendLine(blends.inRect, BlendAngle.Descending, thickness, color); + } + + static void DrawClipTimescale(Rect targetRect, Rect clippedRect, double timeScale) + { + if (timeScale != 1.0) + { + const float xOffset = 4.0f; + const float yOffset = 6.0f; + var segmentLength = timeScale > 1.0f ? 5.0f : 15.0f; + + // clamp to the visible region to reduce the line count (case 1213189), but adject the start segment to match the visuals of drawing targetRect + var startX = clippedRect.min.x - ((clippedRect.min.x - targetRect.min.x) % (segmentLength * 2)); + var endX = clippedRect.max.x; + + var start = new Vector3(startX + xOffset, targetRect.min.y + yOffset, 0.0f); + var end = new Vector3(endX - xOffset, targetRect.min.y + yOffset, 0.0f); + + Graphics.DrawDottedLine(start, end, segmentLength, DirectorStyles.Instance.customSkin.colorClipFont); + Graphics.DrawDottedLine(start + new Vector3(0.0f, 1.0f, 0.0f), end + new Vector3(0.0f, 1.0f, 0.0f), segmentLength, DirectorStyles.Instance.customSkin.colorClipFont); + } + } + + static void DrawClipInOut(Rect targetRect, TimelineClip clip) + { + var assetDuration = TimelineHelpers.GetClipAssetEndTime(clip); + + bool drawClipOut = assetDuration TimeUtility.kTimeEpsilon; + + bool drawClipIn = clip.clipIn > 0.0; + + if (!drawClipIn && !drawClipOut) + return; + + var rect = targetRect; + + if (drawClipOut) + { + var icon = DirectorStyles.Instance.clipOut; + var iconRect = new Rect(rect.xMax - icon.fixedWidth - 2.0f, + rect.yMin + (rect.height - icon.fixedHeight) * 0.5f, + icon.fixedWidth, icon.fixedHeight); + + GUI.Label(iconRect, GUIContent.none, icon); + } + + if (drawClipIn) + { + var icon = DirectorStyles.Instance.clipIn; + var iconRect = new Rect(2.0f + rect.xMin, + rect.yMin + (rect.height - icon.fixedHeight) * 0.5f, + icon.fixedWidth, icon.fixedHeight); + + GUI.Label(iconRect, GUIContent.none, icon); + } + } + + static void DrawClipLabel(ClipDrawData data, Rect availableRect, Color color) + { + var errorText = data.ClipDrawOptions.errorText; + var hasError = !string.IsNullOrEmpty(errorText); + var textColor = hasError ? DirectorStyles.kClipErrorColor : color; + var tooltip = hasError ? errorText : data.ClipDrawOptions.tooltip; + + if (hasError) + DrawClipLabel(data.title, availableRect, textColor, k_ClipErrorIcons, null, tooltip); + else + DrawClipLabel(data.title, availableRect, textColor, data.leftIcons, data.rightIcons, tooltip); + } + + static void DrawClipLabel(string title, Rect availableRect, Color color, string errorText = "") + { + var hasError = !string.IsNullOrEmpty(errorText); + var textColor = hasError ? DirectorStyles.kClipErrorColor : color; + + if (hasError) + DrawClipLabel(title, availableRect, textColor, k_ClipErrorIcons, null, errorText); + else + DrawClipLabel(title, availableRect, textColor, null, null, errorText); + } + + static void DrawClipLabel(string title, Rect availableRect, Color textColor, IconData[] leftIcons, IconData[] rightIcons, string tooltipMessage = "") + { + s_TitleContent.text = title; + var neededTextWidth = DirectorStyles.Instance.fontClip.CalcSize(s_TitleContent).x; + var neededIconWidthLeft = 0.0f; + var neededIconWidthRight = 0.0f; + + if (leftIcons != null) + for (int i = 0, n = leftIcons.Length; i < n; ++i) + neededIconWidthLeft += leftIcons[i].width + k_IconsPadding; + + if (rightIcons != null) + for (int i = 0, n = rightIcons.Length; i < n; ++i) + neededIconWidthRight += rightIcons[i].width + k_IconsPadding; + + var neededIconWidth = Mathf.Max(neededIconWidthLeft, neededIconWidthRight); + + // Atomic operation: We either show all icons or no icons at all + var showIcons = neededTextWidth / 2.0f + neededIconWidth < availableRect.width / 2.0f; + + if (showIcons) + { + if (leftIcons != null) + DrawClipIcons(leftIcons, IconData.Side.Left, neededTextWidth, availableRect); + + if (rightIcons != null) + DrawClipIcons(rightIcons, IconData.Side.Right, neededTextWidth, availableRect); + } + + if (neededTextWidth > availableRect.width) + s_TitleContent.text = DirectorStyles.Elipsify(title, availableRect.width, neededTextWidth); + + s_TitleContent.tooltip = tooltipMessage; + DrawClipName(availableRect, s_TitleContent, textColor); + } + + static void DrawClipIcons(IconData[] icons, IconData.Side side, float labelWidth, Rect availableRect) + { + var halfText = labelWidth / 2.0f; + var offset = halfText + k_IconsPadding; + + foreach (var iconData in icons) + { + offset += iconData.width / 2.0f + k_IconsPadding; + + var iconRect = + new Rect(0.0f, 0.0f, iconData.width, iconData.height) + { + center = new Vector2(availableRect.center.x + offset * (int)side, availableRect.center.y) + }; + + DrawIcon(iconRect, iconData.tint, iconData.icon); + + offset += iconData.width / 2.0f; + } + } + + static void DrawClipName(Rect rect, GUIContent content, Color textColor) + { + Graphics.ShadowLabel(rect, content, DirectorStyles.Instance.fontClip, textColor, Color.black); + } + + static void DrawIcon(Rect imageRect, Color color, Texture2D icon) + { + GUI.DrawTexture(imageRect, icon, ScaleMode.ScaleAndCrop, true, 0, color, 0, 0); + } + + static void DrawClipBackground(Rect clipCenterSection, bool selected) + { + if (Event.current.type != EventType.Repaint) + return; + + var color = selected ? DirectorStyles.Instance.customSkin.clipSelectedBckg : DirectorStyles.Instance.customSkin.clipBckg; + EditorGUI.DrawRect(clipCenterSection, color); + } + + static Vector3[] s_BlendVertices = new Vector3[3]; + static void DrawClipBlends(ClipBlends blends, Color inColor, Color outColor, Color backgroundColor) + { + switch (blends.inKind) + { + case BlendKind.Ease: + // 2 + // / | + // / | + // 0---1 + EditorGUI.DrawRect(blends.inRect, backgroundColor); + s_BlendVertices[0] = new Vector3(blends.inRect.xMin, blends.inRect.yMax); + s_BlendVertices[1] = new Vector3(blends.inRect.xMax, blends.inRect.yMax); + s_BlendVertices[2] = new Vector3(blends.inRect.xMax, blends.inRect.yMin); + Graphics.DrawPolygonAA(inColor, s_BlendVertices); + break; + case BlendKind.Mix: + // 0---2 + // \ | + // \ | + // 1 + s_BlendVertices[0] = new Vector3(blends.inRect.xMin, blends.inRect.yMin); + s_BlendVertices[1] = new Vector3(blends.inRect.xMax, blends.inRect.yMax); + s_BlendVertices[2] = new Vector3(blends.inRect.xMax, blends.inRect.yMin); + Graphics.DrawPolygonAA(inColor, s_BlendVertices); + break; + } + + if (blends.outKind != BlendKind.None) + { + if (blends.outKind == BlendKind.Ease) + EditorGUI.DrawRect(blends.outRect, backgroundColor); + // 0 + // | \ + // | \ + // 1---2 + s_BlendVertices[0] = new Vector3(blends.outRect.xMin, blends.outRect.yMin); + s_BlendVertices[1] = new Vector3(blends.outRect.xMin, blends.outRect.yMax); + s_BlendVertices[2] = new Vector3(blends.outRect.xMax, blends.outRect.yMax); + Graphics.DrawPolygonAA(outColor, s_BlendVertices); + } + } + + static void DrawClipSwatch(Rect targetRect, Color swatchColor) + { + // Draw Colored Line at the bottom. + var colorRect = targetRect; + colorRect.yMin = colorRect.yMax - k_ClipSwatchLineThickness; + EditorGUI.DrawRect(colorRect, swatchColor); + } + + public static void DrawSimpleClip(TimelineClip clip, Rect targetRect, ClipBorder border, Color overlay, ClipDrawOptions drawOptions) + { + GUI.BeginClip(targetRect); + var clipRect = new Rect(0.0f, 0.0f, targetRect.width, targetRect.height); + + var orgColor = GUI.color; + GUI.color = overlay; + + DrawClipBackground(clipRect, false); + GUI.color = orgColor; + + if (clipRect.width <= k_MinClipWidth) + { + clipRect.width = k_MinClipWidth; + } + + DrawClipSwatch(targetRect, drawOptions.highlightColor * overlay); + + if (targetRect.width >= k_ClipInOutMinWidth) + DrawClipInOut(clipRect, clip); + + var textRect = clipRect; + + textRect.xMin += k_ClipLabelPadding; + textRect.xMax -= k_ClipLabelPadding; + + if (textRect.width > k_ClipLabelMinWidth) + DrawClipLabel(clip.displayName, textRect, Color.white, drawOptions.errorText); + + DrawClipSelectionBorder(clipRect, border, ClipBlends.kNone); + + GUI.EndClip(); + } + + public static void DrawDefaultClip(ClipDrawData drawData) + { + var customSkin = DirectorStyles.Instance.customSkin; + var blendInColor = drawData.selected ? customSkin.clipBlendInSelected : customSkin.clipBlendIn; + var blendOutColor = drawData.selected ? customSkin.clipBlendOutSelected : customSkin.clipBlendOut; + var easeBackgroundColor = customSkin.clipEaseBckgColor; + + DrawClipBlends(drawData.clipBlends, blendInColor, blendOutColor, easeBackgroundColor); + DrawClipBackground(drawData.clipCenterSection, drawData.selected); + + if (drawData.targetRect.width > k_MinClipWidth) + { + DrawClipEditorBackground(drawData); + } + else + { + drawData.targetRect.width = k_MinClipWidth; + drawData.clipCenterSection.width = k_MinClipWidth; + } + + DrawClipTimescale(drawData.targetRect, drawData.clippedRect, drawData.clip.timeScale); + + if (drawData.targetRect.width >= k_ClipInOutMinWidth) + DrawClipInOut(drawData.targetRect, drawData.clip); + + var labelRect = drawData.clipCenterSection; + + if (drawData.targetRect.width >= k_ClipLoopsMinWidth) + { + bool selected = drawData.selected || drawData.inlineCurvesSelected; + + if (selected) + { + if (drawData.loopRects != null && drawData.loopRects.Any()) + { + DrawLoops(drawData); + + var l = drawData.loopRects[0]; + labelRect.xMax = Math.Min(labelRect.xMax, l.x - drawData.unclippedRect.x); + } + } + } + + labelRect.xMin += k_ClipLabelPadding; + labelRect.xMax -= k_ClipLabelPadding; + + if (labelRect.width > k_ClipLabelMinWidth) + { + DrawClipLabel(drawData, labelRect, Color.white); + } + + DrawClipSwatch(drawData.targetRect, drawData.ClipDrawOptions.highlightColor); + DrawClipBorder(drawData); + } + + static void DrawClipEditorBackground(ClipDrawData drawData) + { + var isRepaint = (Event.current.type == EventType.Repaint); + if (isRepaint && drawData.clipEditor != null) + { + var customBodyRect = drawData.clippedRect; + customBodyRect.yMin += k_ClipInlineWidth; + customBodyRect.yMax -= k_ClipSwatchLineThickness; + var region = new ClipBackgroundRegion(customBodyRect, drawData.localVisibleStartTime, drawData.localVisibleEndTime); + try + { + drawData.clipEditor.DrawBackground(drawData.clip, region); + } + catch (Exception e) + { + Debug.LogException(e); + } + } + } + + public static void DrawAnimationRecordBorder(ClipDrawData drawData) + { + if (!drawData.clip.parentTrack.IsRecordingToClip(drawData.clip)) + return; + + var time = new DiscreteTime(TimelineWindow.instance.state.editSequence.time); + var start = new DiscreteTime(drawData.clip.start + drawData.clip.mixInDuration); + var end = new DiscreteTime(drawData.clip.end - drawData.clip.mixOutDuration); + + if (time < start || time >= end) + return; + + DrawClipSelectionBorder(drawData.clipCenterSection, ClipBorder.Recording(), ClipBlends.kNone); + } + + public static void DrawRecordProhibited(ClipDrawData drawData) + { + DrawRecordInvalidClip(drawData); + DrawRecordOnBlend(drawData); + } + + public static void DrawRecordOnBlend(ClipDrawData drawData) + { + double time = TimelineWindow.instance.state.editSequence.time; + if (time >= drawData.clip.start && time < drawData.clip.start + drawData.clip.mixInDuration) + { + Rect r = Rect.MinMaxRect(drawData.clippedRect.xMin, drawData.clippedRect.yMin, drawData.clipCenterSection.xMin, drawData.clippedRect.yMax); + DrawInvalidRecordIcon(r, Styles.s_ClipNoRecordInBlend); + } + + if (time <= drawData.clip.end && time > drawData.clip.end - drawData.clip.mixOutDuration) + { + Rect r = Rect.MinMaxRect(drawData.clipCenterSection.xMax, drawData.clippedRect.yMin, drawData.clippedRect.xMax, drawData.clippedRect.yMax); + DrawInvalidRecordIcon(r, Styles.s_ClipNoRecordInBlend); + } + } + + public static void DrawRecordInvalidClip(ClipDrawData drawData) + { + if (drawData.clip.recordable) + return; + + double time = TimelineWindow.instance.state.editSequence.time; + if (time < drawData.clip.start + drawData.clip.mixInDuration || time > drawData.clip.end - drawData.clip.mixOutDuration) + return; + + DrawInvalidRecordIcon(drawData.clipCenterSection, Styles.s_ClipNotRecorable); + } + + public static void DrawInvalidRecordIcon(Rect rect, GUIContent helpText) + { + EditorGUI.DrawRect(rect, new Color(0, 0, 0, 0.30f)); + + var icon = Styles.s_IconNoRecord; + if (rect.width < icon.width || rect.height < icon.height) + return; + + float x = rect.x + (rect.width - icon.width) * 0.5f; + float y = rect.y + (rect.height - icon.height) * 0.5f; + Rect r = new Rect(x, y, icon.width, icon.height); + GUI.Label(r, helpText); + GUI.DrawTexture(r, icon, ScaleMode.ScaleAndCrop, true, 0, Color.white, 0, 0); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/ClipDrawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/ClipDrawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e1493e6eb116f61eb317b4cc78c1b7a55a38327f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/ClipDrawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 63118a0c9ee42ac46b7f30e793177a76 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/InfiniteTrackDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/InfiniteTrackDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..3d851be1fa82d909fd40e8ade0a69f8323ccd3e3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/InfiniteTrackDrawer.cs @@ -0,0 +1,87 @@ +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class InfiniteTrackDrawer : TrackDrawer + { + readonly IPropertyKeyDataSource m_DataSource; + Rect m_TrackRect; + + public InfiniteTrackDrawer(IPropertyKeyDataSource dataSource) + { + m_DataSource = dataSource; + } + + public bool CanDraw(TrackAsset track, WindowState state) + { + var keys = m_DataSource.GetKeys(); + var isTrackEmpty = track.clips.Length == 0; + + return keys != null || (state.IsArmedForRecord(track) && isTrackEmpty); + } + + static void DrawRecordBackground(Rect trackRect) + { + var styles = DirectorStyles.Instance; + + EditorGUI.DrawRect(trackRect, styles.customSkin.colorInfiniteTrackBackgroundRecording); + + Graphics.ShadowLabel(trackRect, + DirectorStyles.Elipsify(DirectorStyles.recordingLabel.text, trackRect, styles.fontClip), + styles.fontClip, Color.white, Color.black); + } + + public override bool DrawTrack(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state) + { + m_TrackRect = trackRect; + + if (!CanDraw(trackAsset, state)) + return true; + + if (state.recording && state.IsArmedForRecord(trackAsset)) + DrawRecordBackground(trackRect); + + if (m_DataSource.GetKeys() != null && m_DataSource.GetKeys().Length > 0 || state.recording) + GUI.Box(trackRect, GUIContent.none, DirectorStyles.Instance.infiniteTrack); + + var shadowRect = trackRect; + shadowRect.yMin = shadowRect.yMax; + shadowRect.height = 15.0f; + if (Event.current.type == EventType.Repaint) + DirectorStyles.Instance.bottomShadow.Draw(shadowRect, false, false, false, false); + + var keys = m_DataSource.GetKeys(); + if (keys != null && keys.Length > 0) + { + foreach (var k in keys) + DrawKeyFrame(k, state); + } + + return true; + } + + void DrawKeyFrame(float key, WindowState state) + { + var x = state.TimeToPixel(key); + var bounds = new Rect(x, m_TrackRect.yMin + 3.0f, 1.0f, m_TrackRect.height - 6.0f); + + if (!m_TrackRect.Overlaps(bounds)) + return; + + var iconWidth = DirectorStyles.Instance.keyframe.fixedWidth; + var iconHeight = DirectorStyles.Instance.keyframe.fixedHeight; + + var keyframeRect = bounds; + keyframeRect.width = iconWidth; + keyframeRect.height = iconHeight; + keyframeRect.xMin -= iconWidth / 2.0f; + keyframeRect.yMin = m_TrackRect.yMin + ((m_TrackRect.height - iconHeight) / 2.0f); + + // case 890650 : Make sure to use GUI.Label and not GUI.Box since the number of key frames can vary while dragging keys in the inline curves causing hotControls to be desynchronized + GUI.Label(keyframeRect, GUIContent.none, DirectorStyles.Instance.keyframe); + + EditorGUI.DrawRect(bounds, DirectorStyles.Instance.customSkin.colorInfiniteClipLine); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/InfiniteTrackDrawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/InfiniteTrackDrawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..fd7c0b54d797a061ed3dcd0693c7da2bb0651684 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/InfiniteTrackDrawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5ea6a8a826704f743b3b0ce3e9d3c9a9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers.meta new file mode 100644 index 0000000000000000000000000000000000000000..920cf3a6d977b552f10fd4493b65e4ab685db448 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 16388ae022a89264b84107f0c1b44680 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/ClipsLayer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/ClipsLayer.cs new file mode 100644 index 0000000000000000000000000000000000000000..a4c1be394a0760bead3c96bfd330b27481a9858b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/ClipsLayer.cs @@ -0,0 +1,56 @@ +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class ClipsLayer : ItemsLayer + { + static readonly GUIStyle k_ConnectorIcon = DirectorStyles.Instance.connector; + + public ClipsLayer(Layer layerOrder, IRowGUI parent) : base(layerOrder) + { + var track = parent.asset; + track.SortClips(); + TimelineClipGUI previousClipGUI = null; + + foreach (var clip in track.clips) + { + var oldClipGUI = ItemToItemGui.GetGuiForClip(clip); + var isInvalid = oldClipGUI != null && oldClipGUI.isInvalid; // HACK Make sure to carry invalidy state when refereshing the cache. + + var currentClipGUI = new TimelineClipGUI(clip, parent, this) {isInvalid = isInvalid}; + if (previousClipGUI != null) previousClipGUI.nextClip = currentClipGUI; + currentClipGUI.previousClip = previousClipGUI; + AddItem(currentClipGUI); + previousClipGUI = currentClipGUI; + } + } + + public override void Draw(Rect rect, WindowState state) + { + base.Draw(rect, state); //draw clips + DrawConnector(items); + } + + static void DrawConnector(List clips) + { + if (Event.current.type != EventType.Repaint) + return; + + foreach (var clip in clips) + { + if (clip.previousClip != null && clip.visible && clip.treeViewRect.width > 14 && + (DiscreteTime)clip.start == (DiscreteTime)clip.previousClip.end) + { + // draw little connector widget + var localRect = clip.treeViewRect; + localRect.x -= Mathf.Floor(k_ConnectorIcon.fixedWidth / 2.0f); + localRect.width = k_ConnectorIcon.fixedWidth; + localRect.height = k_ConnectorIcon.fixedHeight; + GUI.Label(localRect, GUIContent.none, k_ConnectorIcon); + } + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/ClipsLayer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/ClipsLayer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..58ef8096f32f9758d3a1aab45cb19edbd3a1bd8d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/ClipsLayer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a809a4b50addbf44b9023b5e7f9fd4d2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/ItemsLayer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/ItemsLayer.cs new file mode 100644 index 0000000000000000000000000000000000000000..56ca0a512c11b92c2aebcafed2a1ebfa2489f28a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/ItemsLayer.cs @@ -0,0 +1,132 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + enum Layer : byte + { + Clips, + ClipHandles, + Markers, + MarkerHeaderTrack, + MarkersOnHeader + } + + struct LayerZOrder : IComparable + { + Layer m_Layer; + int m_ZOrder; + + public LayerZOrder(Layer layer, int zOrder) + { + m_Layer = layer; + m_ZOrder = zOrder; + } + + public int CompareTo(LayerZOrder other) + { + if (m_Layer == other.m_Layer) + return m_ZOrder.CompareTo(other.m_ZOrder); + return m_Layer.CompareTo(other.m_Layer); + } + + public static LayerZOrder operator++(LayerZOrder x) + { + return new LayerZOrder(x.m_Layer, x.m_ZOrder + 1); + } + + public LayerZOrder ChangeLayer(Layer layer) + { + return new LayerZOrder(layer, m_ZOrder); + } + } + + interface ILayerable + { + LayerZOrder zOrder { get; } + } + + interface IZOrderProvider + { + LayerZOrder Next(); + } + + interface ILayer : IZOrderProvider + { + void Draw(Rect rect, WindowState state); + } + + abstract class ItemsLayer : ILayer where T : TimelineItemGUI + { + // provide a buffer for time-based culling to allow for UI that extends slightly beyond the time (e.g. markers) + // prevents popping of marker visibility. + const int kVisibilityBufferInPixels = 10; + + int m_PreviousLayerStateHash = -1; + LayerZOrder m_LastZOrder; + + public LayerZOrder Next() + { + return m_LastZOrder++; + } + + readonly List m_Items = new List(); + bool m_NeedSort = true; + + public virtual void Draw(Rect rect, WindowState state) + { + if (m_Items.Count <= 0) return; + + Sort(); + + // buffer to prevent flickering of markers at boundaries + var onePixelTime = state.PixelDeltaToDeltaTime(kVisibilityBufferInPixels); + var visibleTime = state.timeAreaShownRange + new Vector2(-onePixelTime, onePixelTime); + var layerViewStateHasChanged = GetLayerViewStateChanged(rect, state); + + foreach (var item in m_Items) + { + item.visible = item.end > visibleTime.x && item.start < visibleTime.y; + if (!item.visible) + continue; + + item.Draw(rect, layerViewStateHasChanged, state); + } + } + + public List items => m_Items; + + protected void AddItem(T item) + { + m_Items.Add(item); + m_NeedSort = true; + } + + protected ItemsLayer(Layer layerOrder) + { + m_LastZOrder = new LayerZOrder(layerOrder, 0); + } + + void Sort() + { + if (!m_NeedSort) + return; + + m_Items.Sort((a, b) => a.zOrder.CompareTo(b.zOrder)); + m_NeedSort = false; + } + + bool GetLayerViewStateChanged(Rect rect, WindowState state) + { + var layerStateHash = rect.GetHashCode().CombineHash(state.viewStateHash); + var layerViewStateHasChanged = layerStateHash != m_PreviousLayerStateHash; + + if (Event.current.type == EventType.Layout && layerViewStateHasChanged) + m_PreviousLayerStateHash = layerStateHash; + + return layerViewStateHasChanged; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/ItemsLayer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/ItemsLayer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5ebff18eb6f159c09feebd3b2e1be69277326210 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/ItemsLayer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ef97f39912c138b4cabdccedfb24093b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/MarkersLayer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/MarkersLayer.cs new file mode 100644 index 0000000000000000000000000000000000000000..bf7b2bfa0d3f6e0b77ed47a851576c789ae1c48c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/MarkersLayer.cs @@ -0,0 +1,80 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class MarkersLayer : ItemsLayer + { + public MarkersLayer(Layer layerOrder, IRowGUI parent) : base(layerOrder) + { + CreateLists(parent); + } + + void CreateLists(IRowGUI parent) + { + var markerCount = parent.asset.GetMarkerCount(); + if (markerCount == 0) return; + + var accumulator = new List(); + var sortedMarkers = new List(parent.asset.GetMarkers()); + var vm = TimelineWindowViewPrefs.GetTrackViewModelData(parent.asset); + + sortedMarkers.Sort((lhs, rhs) => + { + // Sort by time first + var timeComparison = lhs.time.CompareTo(rhs.time); + if (timeComparison != 0) + return timeComparison; + + // If there's a collision, sort by edit timestamp + var lhsObject = lhs as object; + var rhsObject = rhs as object; + + if (lhsObject.Equals(null) || rhsObject.Equals(null)) + return 0; + + var lhsHash = lhsObject.GetHashCode(); + var rhsHash = rhsObject.GetHashCode(); + + if (vm.markerTimeStamps.ContainsKey(lhsHash) && vm.markerTimeStamps.ContainsKey(rhsHash)) + return vm.markerTimeStamps[lhsHash].CompareTo(vm.markerTimeStamps[rhsHash]); + + return 0; + }); + + foreach (var current in sortedMarkers) + { + // TODO: Take zoom factor into account? + if (accumulator.Count > 0 && Math.Abs(current.time - accumulator[accumulator.Count - 1].time) > TimeUtility.kTimeEpsilon) + ProcessAccumulator(accumulator, parent); + + accumulator.Add(current); + } + + ProcessAccumulator(accumulator, parent); + } + + void ProcessAccumulator(List accumulator, IRowGUI parent) + { + if (accumulator.Count == 0) return; + + if (accumulator.Count == 1) + { + AddItem(new TimelineMarkerGUI(accumulator[0], parent, this)); + } + else + { + // Ensure that the cluster is always considered *below* the markers it contains. + var clusterZOrder = Next(); + AddItem( + new TimelineMarkerClusterGUI( + accumulator.Select(m => new TimelineMarkerGUI(m, parent, this)).ToList(), + parent, this, clusterZOrder)); + } + + accumulator.Clear(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/MarkersLayer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/MarkersLayer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..32b0787575725481a0fc7a3b6a376926d8c3fbe6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/Layers/MarkersLayer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bea62e1faac8f9a48a4cb919ea05cb6a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/TrackDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/TrackDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..2cb87143d437b806e9eacd5778abd8f90d021312 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/TrackDrawer.cs @@ -0,0 +1,50 @@ +using System; +using UnityEngine; +using UnityEngine.Timeline; +namespace UnityEditor.Timeline +{ + class TrackDrawer : GUIDrawer + { + internal WindowState sequencerState { get; set; } + + + public static TrackDrawer CreateInstance(TrackAsset trackAsset) + { + if (trackAsset == null) + return Activator.CreateInstance(); + + TrackDrawer drawer; + + try + { + drawer = (TrackDrawer)Activator.CreateInstance(TimelineHelpers.GetCustomDrawer(trackAsset.GetType())); + } + catch (Exception) + { + drawer = Activator.CreateInstance(); + } + + drawer.track = trackAsset; + return drawer; + } + + protected TrackAsset track { get; private set; } + + public virtual bool HasCustomTrackHeaderButton() + { + return false; + } + + public virtual void DrawTrackHeaderButton(Rect rect, WindowState state) {} + + public virtual bool DrawTrack(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state) + { + return false; + } + + public virtual void DrawRecordingBackground(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state) + { + EditorGUI.DrawRect(trackRect, DirectorStyles.Instance.customSkin.colorTrackBackgroundRecording); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/TrackDrawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/TrackDrawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..95880431138526b4a5353d69dba68f37f5c4da50 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/TrackDrawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9a0f991b6c2f45b44b92e163f9969e8e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/TrackItemsDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/TrackItemsDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..9807e411cc84d955a9e1f834892d96cc4151f817 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/TrackItemsDrawer.cs @@ -0,0 +1,38 @@ +using System.Collections.Generic; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + struct TrackItemsDrawer + { + List m_Layers; + ClipsLayer m_ClipsLayer; + + public List clips => m_ClipsLayer.items; + + public TrackItemsDrawer(IRowGUI parent) + { + m_Layers = null; + m_ClipsLayer = null; + BuildGUICache(parent); + } + + void BuildGUICache(IRowGUI parent) + { + m_ClipsLayer = new ClipsLayer(Layer.Clips, parent); + m_Layers = new List + { + m_ClipsLayer, + new MarkersLayer(Layer.Markers, parent) + }; + } + + public void Draw(Rect rect, WindowState state) + { + foreach (var layer in m_Layers) + { + layer.Draw(rect, state); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/TrackItemsDrawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/TrackItemsDrawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..d41923c7a72dedc941c438bb753f5575a0583d59 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Drawers/TrackItemsDrawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c7137daaeb11e8647bf1ade9b7e9aa97 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/IPropertyKeyDataSource.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/IPropertyKeyDataSource.cs new file mode 100644 index 0000000000000000000000000000000000000000..a26deb692f81d6a5aaca1839beeac7cdca0c4979 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/IPropertyKeyDataSource.cs @@ -0,0 +1,71 @@ +using System.Collections.Generic; +using System.Linq; +using System.Text; +using UnityEditorInternal; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + interface IPropertyKeyDataSource + { + float[] GetKeys(); // Get the keys + Dictionary GetDescriptions(); // Caches for descriptions + } + + abstract class BasePropertyKeyDataSource : IPropertyKeyDataSource + { + static readonly StringBuilder k_StringBuilder = new StringBuilder(); + + protected abstract AnimationClip animationClip { get; } + + public virtual float[] GetKeys() + { + if (animationClip == null) + return null; + + var info = AnimationClipCurveCache.Instance.GetCurveInfo(animationClip); + return info.keyTimes.Select(TransformKeyTime).ToArray(); + } + + public virtual Dictionary GetDescriptions() + { + var map = new Dictionary(); + var info = AnimationClipCurveCache.Instance.GetCurveInfo(animationClip); + var processed = new HashSet(); + + foreach (var b in info.bindings) + { + var groupID = b.GetGroupID(); + if (processed.Contains(groupID)) + continue; + + var group = info.GetGroupBinding(groupID); + var prefix = AnimationWindowUtility.GetNicePropertyGroupDisplayName(b.type, b.propertyName); + + foreach (var t in info.keyTimes) + { + k_StringBuilder.Length = 0; + + var key = TransformKeyTime(t); + if (map.ContainsKey(key)) + k_StringBuilder.Append(map[key]) + .Append('\n'); + + k_StringBuilder.Append(prefix) + .Append(" : ") + .Append(group.GetDescription(key)); + + map[key] = k_StringBuilder.ToString(); + } + processed.Add(groupID); + } + + return map; + } + + protected virtual float TransformKeyTime(float keyTime) + { + return keyTime; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/IPropertyKeyDataSource.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/IPropertyKeyDataSource.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..4c8993c22c10295491fed69ada8e1f696daf708d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/IPropertyKeyDataSource.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ee83d5e1ad2ac4c9aa39e3a6f256062e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/IRowGUI.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/IRowGUI.cs new file mode 100644 index 0000000000000000000000000000000000000000..0745c6a5bc4fb1d0c7c6f3cf8954e36a92a5a0d3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/IRowGUI.cs @@ -0,0 +1,16 @@ +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + interface IRowGUI + { + TrackAsset asset { get; } + Rect boundingRect { get; } + bool locked { get; } + bool showMarkers { get; } + bool muted { get; } + + Rect ToWindowSpace(Rect treeViewRect); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/IRowGUI.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/IRowGUI.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..26dcaed8010be8768dcfd5153cedc794cc8ea73b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/IRowGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5ecec8cdc3ff99e4a9c65635d7e6b043 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui.meta new file mode 100644 index 0000000000000000000000000000000000000000..f19c2d2778f9a45d24227a8805bf0981156f3db5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 9d816a6ab06c6834480f5f45f440e287 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/ISelectable.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/ISelectable.cs new file mode 100644 index 0000000000000000000000000000000000000000..3e4a5d5848b64ad302a55d44aa5da1013eb10be1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/ISelectable.cs @@ -0,0 +1,12 @@ +using System; + +namespace UnityEditor.Timeline +{ + interface ISelectable : ILayerable + { + void Select(); + bool IsSelected(); + void Deselect(); + bool CanSelect(); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/ISelectable.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/ISelectable.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..970ecaa742927e360f3a9e53ab877f44a1a03a65 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/ISelectable.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4acbfc0398bab674f922f693e58f4afc +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineClipGUI.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineClipGUI.cs new file mode 100644 index 0000000000000000000000000000000000000000..7dacc6fb1e65fe0ee23a4edae0cbe2a7ffea118b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineClipGUI.cs @@ -0,0 +1,788 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TimelineClipGUI : TimelineItemGUI, IClipCurveEditorOwner, ISnappable, IAttractable + { + EditorClip m_EditorItem; + + Rect m_ClipCenterSection; + readonly List m_LoopRects = new List(); + + ClipDrawData m_ClipDrawData; + Rect m_MixOutRect = new Rect(); + Rect m_MixInRect = new Rect(); + int m_MinLoopIndex = 1; + + // clip dirty detection + int m_LastDirtyIndex = Int32.MinValue; + bool m_ClipViewDirty = true; + + bool supportResize { get; } + public ClipCurveEditor clipCurveEditor { get; set; } + public TimelineClipGUI previousClip { get; set; } + public TimelineClipGUI nextClip { get; set; } + + static readonly float k_MinMixWidth = 2; + static readonly float k_MaxHandleWidth = 10f; + static readonly float k_MinHandleWidth = 1f; + + bool? m_ShowDrillIcon; + ClipEditor m_ClipEditor; + + static List s_TempSubDirectors = new List(); + + static readonly IconData k_DiggableClipIcon = new IconData(DirectorStyles.LoadIcon("TimelineDigIn")); + + string name + { + get + { + if (string.IsNullOrEmpty(clip.displayName)) + return "(Empty)"; + + return clip.displayName; + } + } + + public bool inlineCurvesSelected => SelectionManager.IsCurveEditorFocused(this); + + public Rect mixOutRect + { + get + { + var percent = clip.mixOutPercentage; + var x = Mathf.Round(treeViewRect.width * (1 - percent)); + var width = Mathf.Round(treeViewRect.width * percent); + m_MixOutRect.Set(x, 0.0f, width, treeViewRect.height); + return m_MixOutRect; + } + } + + public Rect mixInRect + { + get + { + var width = Mathf.Round(treeViewRect.width * clip.mixInPercentage); + m_MixInRect.Set(0.0f, 0.0f, width, treeViewRect.height); + return m_MixInRect; + } + } + + public ClipBlends GetClipBlends() + { + var _mixInRect = mixInRect; + var _mixOutRect = mixOutRect; + + var blendInKind = BlendKind.None; + if (_mixInRect.width > k_MinMixWidth && clip.hasBlendIn) + blendInKind = BlendKind.Mix; + else if (_mixInRect.width > k_MinMixWidth) + blendInKind = BlendKind.Ease; + + var blendOutKind = BlendKind.None; + if (_mixOutRect.width > k_MinMixWidth && clip.hasBlendOut) + blendOutKind = BlendKind.Mix; + else if (_mixOutRect.width > k_MinMixWidth) + blendOutKind = BlendKind.Ease; + + return new ClipBlends(blendInKind, _mixInRect, blendOutKind, _mixOutRect); + } + + public override double start + { + get { return clip.start; } + } + + public override double end + { + get { return clip.end; } + } + + public bool supportsLooping + { + get { return clip.SupportsLooping(); } + } + + // for the inline curve editor, only show loops if we recorded the asset + bool IClipCurveEditorOwner.showLoops + { + get { return clip.SupportsLooping() && (clip.asset is AnimationPlayableAsset); } + } + + TrackAsset IClipCurveEditorOwner.owner + { + get { return clip.parentTrack; } + } + + public bool supportsSubTimelines + { + get { return m_ClipEditor.supportsSubTimelines; } + } + + public int minLoopIndex + { + get { return m_MinLoopIndex; } + } + + public Rect clippedRect { get; private set; } + + public override void Select() + { + zOrder = zOrderProvider.Next(); + SelectionManager.Add(clip); + if (clipCurveEditor != null && SelectionManager.Count() == 1) + SelectionManager.SelectInlineCurveEditor(this); + } + + public override bool IsSelected() + { + return SelectionManager.Contains(clip); + } + + public override void Deselect() + { + SelectionManager.Remove(clip); + if (inlineCurvesSelected) + SelectionManager.SelectInlineCurveEditor(null); + } + + public override bool CanSelect() + { + ClipBlends clipBlends = GetClipBlends(); + + //clips that do not overlap are always selectable + if (clipBlends.inKind != BlendKind.Mix && clipBlends.outKind != BlendKind.Mix) + return true; + + Vector2 mousePos = Event.current.mousePosition - rect.position; + return m_ClipCenterSection.Contains(mousePos) || IsPointLocatedInClipBlend(mousePos, clipBlends); + } + + static bool IsPointLocatedInClipBlend(Vector2 pt, ClipBlends blends) + { + if (blends.inRect.Contains(pt)) + return Sign(pt, blends.inRect.min, blends.inRect.max) < 0; + + if (blends.outRect.Contains(pt)) + return Sign(pt, blends.outRect.min, blends.outRect.max) >= 0; + + return false; + } + + static float Sign(Vector2 point, Vector2 linePoint1, Vector2 linePoint2) + { + return (point.x - linePoint2.x) * (linePoint1.y - linePoint2.y) - (linePoint1.x - linePoint2.x) * (point.y - linePoint2.y); + } + + public override ITimelineItem item + { + get { return ItemsUtils.ToItem(clip); } + } + + IZOrderProvider zOrderProvider { get; } + + public TimelineClipHandle leftHandle { get; } + public TimelineClipHandle rightHandle { get; } + + public TimelineClipGUI(TimelineClip clip, IRowGUI parent, IZOrderProvider provider) : base(parent) + { + zOrderProvider = provider; + zOrder = provider.Next(); + + m_EditorItem = EditorClipFactory.GetEditorClip(clip); + m_ClipEditor = CustomTimelineEditorCache.GetClipEditor(clip); + + supportResize = true; + + leftHandle = new TimelineClipHandle(this, TrimEdge.Start); + rightHandle = new TimelineClipHandle(this, TrimEdge.End); + + ItemToItemGui.Add(clip, this); + } + + void CreateInlineCurveEditor(WindowState state) + { + if (clipCurveEditor != null) + return; + + var animationClip = clip.animationClip; + + if (animationClip != null && animationClip.empty) + animationClip = null; + + // prune out clips coming from FBX + if (animationClip != null && !clip.recordable) + return; // don't show, even if there are curves + + if (animationClip == null && !clip.HasAnyAnimatableParameters()) + return; // nothing to show + + state.AddEndFrameDelegate((istate, currentEvent) => + { + clipCurveEditor = new ClipCurveEditor(CurveDataSource.Create(this), TimelineWindow.instance, clip.parentTrack); + return true; + }); + } + + public TimelineClip clip + { + get { return m_EditorItem.clip; } + } + + // Draw the actual clip. Defers to the track drawer for customization + void UpdateDrawData(WindowState state, Rect drawRect, string title, bool selected, bool previousClipSelected, float rectXOffset) + { + m_ClipDrawData.clip = clip; + m_ClipDrawData.targetRect = drawRect; + m_ClipDrawData.clipCenterSection = m_ClipCenterSection; + m_ClipDrawData.unclippedRect = treeViewRect; + m_ClipDrawData.title = title; + m_ClipDrawData.selected = selected; + m_ClipDrawData.inlineCurvesSelected = inlineCurvesSelected; + m_ClipDrawData.previousClip = previousClip != null ? previousClip.clip : null; + m_ClipDrawData.previousClipSelected = previousClipSelected; + + Vector3 shownAreaTime = state.timeAreaShownRange; + m_ClipDrawData.localVisibleStartTime = clip.ToLocalTimeUnbound(Math.Max(clip.start, shownAreaTime.x)); + m_ClipDrawData.localVisibleEndTime = clip.ToLocalTimeUnbound(Math.Min(clip.end, shownAreaTime.y)); + + m_ClipDrawData.clippedRect = new Rect(clippedRect.x - rectXOffset, 0.0f, clippedRect.width, clippedRect.height); + + m_ClipDrawData.minLoopIndex = minLoopIndex; + m_ClipDrawData.loopRects = m_LoopRects; + m_ClipDrawData.supportsLooping = supportsLooping; + m_ClipDrawData.clipBlends = GetClipBlends(); + m_ClipDrawData.clipEditor = m_ClipEditor; + m_ClipDrawData.ClipDrawOptions = UpdateClipDrawOptions(m_ClipEditor, clip); + + UpdateClipIcons(state); + } + + void UpdateClipIcons(WindowState state) + { + // Pass 1 - gather size + int required = 0; + bool requiresDigIn = ShowDrillIcon(state.editSequence.director); + if (requiresDigIn) + required++; + + var icons = m_ClipDrawData.ClipDrawOptions.icons; + foreach (var icon in icons) + { + if (icon != null) + required++; + } + + // Pass 2 - copy icon data + if (required == 0) + { + m_ClipDrawData.rightIcons = null; + return; + } + + if (m_ClipDrawData.rightIcons == null || m_ClipDrawData.rightIcons.Length != required) + m_ClipDrawData.rightIcons = new IconData[required]; + + int index = 0; + if (requiresDigIn) + m_ClipDrawData.rightIcons[index++] = k_DiggableClipIcon; + + foreach (var icon in icons) + { + if (icon != null) + m_ClipDrawData.rightIcons[index++] = new IconData(icon); + } + } + + static ClipDrawOptions UpdateClipDrawOptions(ClipEditor clipEditor, TimelineClip clip) + { + try + { + return clipEditor.GetClipOptions(clip); + } + catch (Exception e) + { + Debug.LogException(e); + } + + return CustomTimelineEditorCache.GetDefaultClipEditor().GetClipOptions(clip); + } + + static void DrawClip(ClipDrawData drawData) + { + ClipDrawer.DrawDefaultClip(drawData); + + if (drawData.clip.asset is AnimationPlayableAsset) + { + var state = TimelineWindow.instance.state; + if (state.recording && state.IsArmedForRecord(drawData.clip.parentTrack)) + { + ClipDrawer.DrawAnimationRecordBorder(drawData); + ClipDrawer.DrawRecordProhibited(drawData); + } + } + } + + public void DrawGhostClip(Rect targetRect) + { + DrawSimpleClip(targetRect, ClipBorder.Selection(), new Color(1.0f, 1.0f, 1.0f, 0.5f)); + } + + public void DrawInvalidClip(Rect targetRect) + { + DrawSimpleClip(targetRect, ClipBorder.Selection(), DirectorStyles.Instance.customSkin.colorInvalidClipOverlay); + } + + void DrawSimpleClip(Rect targetRect, ClipBorder border, Color overlay) + { + var drawOptions = UpdateClipDrawOptions(CustomTimelineEditorCache.GetClipEditor(clip), clip); + ClipDrawer.DrawSimpleClip(clip, targetRect, border, overlay, drawOptions); + } + + void DrawInto(Rect drawRect, WindowState state) + { + if (Event.current.type != EventType.Repaint) + return; + + // create the inline curve editor if not already created + CreateInlineCurveEditor(state); + + // @todo optimization, most of the calculations (rect, offsets, colors, etc.) could be cached + // and rebuilt when the hash of the clip changes. + + if (isInvalid) + { + DrawInvalidClip(treeViewRect); + return; + } + + GUI.BeginClip(drawRect); + + var originRect = new Rect(0.0f, 0.0f, drawRect.width, drawRect.height); + string clipLabel = name; + var selected = SelectionManager.Contains(clip); + var previousClipSelected = previousClip != null && SelectionManager.Contains(previousClip.clip); + + if (selected && 1.0 != clip.timeScale) + clipLabel += " " + clip.timeScale.ToString("F2") + "x"; + + UpdateDrawData(state, originRect, clipLabel, selected, previousClipSelected, drawRect.x); + DrawClip(m_ClipDrawData); + + GUI.EndClip(); + + if (clip.parentTrack != null && !clip.parentTrack.lockedInHierarchy) + { + if (selected && supportResize) + { + var cursorRect = rect; + cursorRect.xMin += leftHandle.boundingRect.width; + cursorRect.xMax -= rightHandle.boundingRect.width; + EditorGUIUtility.AddCursorRect(cursorRect, MouseCursor.MoveArrow); + } + + if (supportResize) + { + var handleWidth = Mathf.Clamp(drawRect.width * 0.3f, k_MinHandleWidth, k_MaxHandleWidth); + + leftHandle.Draw(drawRect, handleWidth, state); + rightHandle.Draw(drawRect, handleWidth, state); + } + } + } + + void CalculateClipRectangle(Rect trackRect, WindowState state) + { + if (m_ClipViewDirty) + { + var clipRect = RectToTimeline(trackRect, state); + treeViewRect = clipRect; + + // calculate clipped rect + clipRect.xMin = Mathf.Max(clipRect.xMin, trackRect.xMin); + clipRect.xMax = Mathf.Min(clipRect.xMax, trackRect.xMax); + + if (clipRect.width > 0 && clipRect.width < 2) + { + clipRect.width = 5.0f; + } + + clippedRect = clipRect; + } + } + + void AddToSpacePartitioner(WindowState state) + { + if (Event.current.type == EventType.Repaint && !parent.locked) + state.spacePartitioner.AddBounds(this, rect); + } + + void CalculateBlendRect() + { + m_ClipCenterSection = treeViewRect; + m_ClipCenterSection.x = 0; + m_ClipCenterSection.y = 0; + + m_ClipCenterSection.xMin = Mathf.Round(treeViewRect.width * clip.mixInPercentage); + m_ClipCenterSection.width = Mathf.Round(treeViewRect.width); + m_ClipCenterSection.xMax -= Mathf.Round(mixOutRect.width + treeViewRect.width * clip.mixInPercentage); + } + + // Entry point to the Clip Drawing... + public override void Draw(Rect trackRect, bool trackRectChanged, WindowState state) + { + // if the clip has changed, fire the appropriate callback + DetectClipChanged(trackRectChanged); + + // update the clip projected rectangle on the timeline + CalculateClipRectangle(trackRect, state); + + AddToSpacePartitioner(state); + + // update the blend rects (when clip overlaps with others) + CalculateBlendRect(); + + // update the loop rects (when clip loops) + CalculateLoopRects(trackRect, state); + + DrawExtrapolation(trackRect, treeViewRect); + + DrawInto(treeViewRect, state); + + ResetClipChanged(); + } + + void DetectClipChanged(bool trackRectChanged) + { + if (Event.current.type == EventType.Layout) + { + if (clip.DirtyIndex != m_LastDirtyIndex) + { + m_ClipViewDirty = true; + + try + { + m_ClipEditor.OnClipChanged(clip); + } + catch (Exception e) + { + Debug.LogException(e); + } + + m_LastDirtyIndex = clip.DirtyIndex; + } + m_ClipViewDirty |= trackRectChanged; + } + } + + void ResetClipChanged() + { + if (Event.current.type == EventType.Repaint) + m_ClipViewDirty = false; + } + + GUIStyle GetExtrapolationIcon(TimelineClip.ClipExtrapolation mode) + { + GUIStyle extrapolationIcon = null; + + switch (mode) + { + case TimelineClip.ClipExtrapolation.None: return null; + case TimelineClip.ClipExtrapolation.Hold: extrapolationIcon = m_Styles.extrapolationHold; break; + case TimelineClip.ClipExtrapolation.Loop: extrapolationIcon = m_Styles.extrapolationLoop; break; + case TimelineClip.ClipExtrapolation.PingPong: extrapolationIcon = m_Styles.extrapolationPingPong; break; + case TimelineClip.ClipExtrapolation.Continue: extrapolationIcon = m_Styles.extrapolationContinue; break; + } + + return extrapolationIcon; + } + + Rect GetPreExtrapolationBounds(Rect trackRect, Rect clipRect, GUIStyle icon) + { + float x = clipRect.xMin - (icon.fixedWidth + 10.0f); + float y = trackRect.yMin + (trackRect.height - icon.fixedHeight) / 2.0f; + + if (previousClip != null) + { + float distance = Mathf.Abs(treeViewRect.xMin - previousClip.treeViewRect.xMax); + + if (distance < icon.fixedWidth) + return new Rect(0.0f, 0.0f, 0.0f, 0.0f); + + if (distance < icon.fixedWidth + 20.0f) + { + float delta = (distance - icon.fixedWidth) / 2.0f; + x = clipRect.xMin - (icon.fixedWidth + delta); + } + } + + return new Rect(x, y, icon.fixedWidth, icon.fixedHeight); + } + + Rect GetPostExtrapolationBounds(Rect trackRect, Rect clipRect, GUIStyle icon) + { + float x = clipRect.xMax + 10.0f; + float y = trackRect.yMin + (trackRect.height - icon.fixedHeight) / 2.0f; + + if (nextClip != null) + { + float distance = Mathf.Abs(nextClip.treeViewRect.xMin - treeViewRect.xMax); + + if (distance < icon.fixedWidth) + return new Rect(0.0f, 0.0f, 0.0f, 0.0f); + + if (distance < icon.fixedWidth + 20.0f) + { + float delta = (distance - icon.fixedWidth) / 2.0f; + x = clipRect.xMax + delta; + } + } + + return new Rect(x, y, icon.fixedWidth, icon.fixedHeight); + } + + static void DrawExtrapolationIcon(Rect rect, GUIStyle icon) + { + GUI.Label(rect, GUIContent.none, icon); + } + + void DrawExtrapolation(Rect trackRect, Rect clipRect) + { + if (clip.hasPreExtrapolation) + { + GUIStyle icon = GetExtrapolationIcon(clip.preExtrapolationMode); + + if (icon != null) + { + Rect iconBounds = GetPreExtrapolationBounds(trackRect, clipRect, icon); + + if (iconBounds.width > 1 && iconBounds.height > 1) + DrawExtrapolationIcon(iconBounds, icon); + } + } + + if (clip.hasPostExtrapolation) + { + GUIStyle icon = GetExtrapolationIcon(clip.postExtrapolationMode); + + if (icon != null) + { + Rect iconBounds = GetPostExtrapolationBounds(trackRect, clipRect, icon); + + if (iconBounds.width > 1 && iconBounds.height > 1) + DrawExtrapolationIcon(iconBounds, icon); + } + } + } + + static Rect ProjectRectOnTimeline(Rect rect, Rect trackRect, WindowState state) + { + Rect newRect = rect; + // transform clipRect into pixel-space + newRect.x *= state.timeAreaScale.x; + newRect.width *= state.timeAreaScale.x; + + newRect.x += state.timeAreaTranslation.x + trackRect.xMin; + + // adjust clipRect height and vertical centering + const int clipPadding = 2; + newRect.y = trackRect.y + clipPadding; + newRect.height = trackRect.height - (2 * clipPadding); + return newRect; + } + + void CalculateLoopRects(Rect trackRect, WindowState state) + { + if (!m_ClipViewDirty) + return; + + m_LoopRects.Clear(); + if (clip.duration < WindowState.kTimeEpsilon) + return; + + var times = TimelineHelpers.GetLoopTimes(clip); + var loopDuration = TimelineHelpers.GetLoopDuration(clip); + m_MinLoopIndex = -1; + + // we have a hold, no need to compute all loops + if (!supportsLooping) + { + if (times.Length > 1) + { + var t = times[1]; + float loopTime = (float)(clip.duration - t); + m_LoopRects.Add(ProjectRectOnTimeline(new Rect((float)(t + clip.start), 0, loopTime, 0), trackRect, state)); + } + return; + } + + var range = state.timeAreaShownRange; + var visibleStartTime = range.x - clip.start; + var visibleEndTime = range.y - clip.start; + + for (int i = 1; i < times.Length; i++) + { + var t = times[i]; + + // don't draw off screen loops + if (t > visibleEndTime) + break; + + float loopTime = Mathf.Min((float)(clip.duration - t), (float)loopDuration); + var loopEnd = t + loopTime; + + if (loopEnd < visibleStartTime) + continue; + + m_LoopRects.Add(ProjectRectOnTimeline(new Rect((float)(t + clip.start), 0, loopTime, 0), trackRect, state)); + + if (m_MinLoopIndex == -1) + m_MinLoopIndex = i; + } + } + + public override Rect RectToTimeline(Rect trackRect, WindowState state) + { + var offsetFromTimeSpaceToPixelSpace = state.timeAreaTranslation.x + trackRect.xMin; + + var start = (float)(DiscreteTime)clip.start; + var end = (float)(DiscreteTime)clip.end; + + return Rect.MinMaxRect( + Mathf.Round(start * state.timeAreaScale.x + offsetFromTimeSpaceToPixelSpace), Mathf.Round(trackRect.yMin), + Mathf.Round(end * state.timeAreaScale.x + offsetFromTimeSpaceToPixelSpace), Mathf.Round(trackRect.yMax) + ); + } + + public IEnumerable SnappableEdgesFor(IAttractable attractable, ManipulateEdges manipulateEdges) + { + var edges = new List(); + + bool canAddEdges = !parent.muted; + + if (canAddEdges) + { + // Hack: Trim Start in Ripple mode should not have any snap point added + if (EditMode.editType == EditMode.EditType.Ripple && manipulateEdges == ManipulateEdges.Left) + return edges; + + if (attractable != this) + { + if (EditMode.editType == EditMode.EditType.Ripple) + { + bool skip = false; + + // Hack: Since Trim End and Move in Ripple mode causes other snap point to move on the same track (which is not supported), disable snapping for this special cases... + // TODO Find a proper way to have different snap edges for each edit mode. + if (manipulateEdges == ManipulateEdges.Right) + { + var otherClipGUI = attractable as TimelineClipGUI; + skip = otherClipGUI != null && otherClipGUI.parent == parent; + } + else if (manipulateEdges == ManipulateEdges.Both) + { + var moveHandler = attractable as MoveItemHandler; + skip = moveHandler != null && moveHandler.movingItems.Any(clips => clips.targetTrack == clip.parentTrack && clip.start >= clips.start); + } + + if (skip) + return edges; + } + + AddEdge(edges, clip.start); + AddEdge(edges, clip.end); + } + else + { + if (manipulateEdges == ManipulateEdges.Right) + { + var d = TimelineHelpers.GetClipAssetEndTime(clip); + + if (d < double.MaxValue) + { + if (clip.SupportsLooping()) + { + var l = TimelineHelpers.GetLoopDuration(clip); + + var shownTime = TimelineWindow.instance.state.timeAreaShownRange; + do + { + AddEdge(edges, d, false); + d += l; + } + while (d < shownTime.y); + } + else + { + AddEdge(edges, d, false); + } + } + } + + if (manipulateEdges == ManipulateEdges.Left) + { + var clipInfo = AnimationClipCurveCache.Instance.GetCurveInfo(clip.animationClip); + if (clipInfo != null && clipInfo.keyTimes.Any()) + AddEdge(edges, clip.FromLocalTimeUnbound(clipInfo.keyTimes.Min()), false); + } + } + } + return edges; + } + + public bool ShouldSnapTo(ISnappable snappable) + { + return true; + } + + bool ShowDrillIcon(PlayableDirector resolver) + { + if (!m_ShowDrillIcon.HasValue || TimelineWindow.instance.hierarchyChangedThisFrame) + { + var nestable = m_ClipEditor.supportsSubTimelines; + m_ShowDrillIcon = nestable && resolver != null; + if (m_ShowDrillIcon.Value) + { + s_TempSubDirectors.Clear(); + try + { + m_ClipEditor.GetSubTimelines(clip, resolver, s_TempSubDirectors); + } + catch (Exception e) + { + Debug.LogException(e); + } + + m_ShowDrillIcon &= s_TempSubDirectors.Count > 0; + } + } + + return m_ShowDrillIcon.Value; + } + + static void AddEdge(List edges, double time, bool showEdgeHint = true) + { + var shownTime = TimelineWindow.instance.state.timeAreaShownRange; + if (time >= shownTime.x && time <= shownTime.y) + edges.Add(new Edge(time, showEdgeHint)); + } + + public void SelectCurves() + { + SelectionManager.SelectOnly(clip); + SelectionManager.SelectInlineCurveEditor(this); + } + + public void ValidateCurvesSelection() + { + if (!IsSelected()) //if clip is not selected, deselect the inline curve + SelectionManager.SelectInlineCurveEditor(null); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineClipGUI.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineClipGUI.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..4e94156cf073825197dc7dd0f84c51b4b32b98d4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineClipGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3c01b61b3a6887c49a15276fd38be918 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineItemGUI.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineItemGUI.cs new file mode 100644 index 0000000000000000000000000000000000000000..e2ccb5c81802039e4a423d78970248b121cc9102 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineItemGUI.cs @@ -0,0 +1,93 @@ +using System; +using System.Collections.Generic; +using UnityEngine.Timeline; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + static class ItemToItemGui + { + static Dictionary s_ItemToItemGUI = + new Dictionary(); + + public static void Add(TimelineClip clip, TimelineItemGUI gui) + { + s_ItemToItemGUI[clip] = gui; + } + + public static void Add(IMarker marker, TimelineItemGUI gui) + { + s_ItemToItemGUI[marker] = gui; + } + + public static TimelineClipGUI GetGuiForClip(TimelineClip clip) + { + return GetGuiForItem(clip) as TimelineClipGUI; + } + + public static TimelineMarkerGUI GetGuiForMarker(IMarker marker) + { + return GetGuiForItem(marker) as TimelineMarkerGUI; + } + + static TimelineItemGUI GetGuiForItem(object item) + { + if (item == null) + return null; + + TimelineItemGUI gui; + s_ItemToItemGUI.TryGetValue(item, out gui); + return gui; + } + } + + abstract class TimelineItemGUI : ISelectable + { + protected readonly DirectorStyles m_Styles; + + public abstract ITimelineItem item { get; } + public abstract double start { get; } + public abstract double end { get; } + public abstract void Draw(Rect rect, bool rectChanged, WindowState state); + public abstract Rect RectToTimeline(Rect trackRect, WindowState state); + + public virtual void Select() {} + public virtual bool IsSelected() { return false; } + public virtual void Deselect() {} + public virtual bool CanSelect() { return true; } + + public virtual void StartDrag() {} + public virtual void StopDrag() {} + + public LayerZOrder zOrder { get; set; } + + public bool visible { get; set; } + public bool isInvalid { get; set; } + + public IRowGUI parent { get; } + + public Rect rect + { + get { return parent.ToWindowSpace(treeViewRect); } + } + + public Rect treeViewRect + { + get { return m_TreeViewRect; } + protected set + { + m_TreeViewRect = value; + if (value.width < 0.0f) + m_TreeViewRect.width = 1.0f; + } + } + + Rect m_TreeViewRect; + + protected TimelineItemGUI(IRowGUI parent) + { + this.parent = parent; + m_Styles = DirectorStyles.Instance; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineItemGUI.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineItemGUI.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a38143d6ea1e96f73872b17d7c8fd0ee8a75ab28 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineItemGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6f515f8ecd3b6a546b90abaae2553f99 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineMarkerClusterGUI.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineMarkerClusterGUI.cs new file mode 100644 index 0000000000000000000000000000000000000000..62108f5709f0175e0ba24e06cfcc407e1e39b077 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineMarkerClusterGUI.cs @@ -0,0 +1,150 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; + +using UnityObject = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class TimelineMarkerClusterGUI : TimelineItemGUI + { + readonly List m_MarkerGUIs; + readonly IZOrderProvider m_ZOrderProvider; + + public TimelineMarkerGUI topMarker + { + get { return m_MarkerGUIs.LastOrDefault(); } + } + + TimelineMarkerGUI m_ManipulatedMarker; + + public TimelineMarkerClusterGUI(List guis, IRowGUI parent, + IZOrderProvider zOrderProvider, LayerZOrder layerZOrder) + : base(parent) + { + m_MarkerGUIs = guis; + m_ZOrderProvider = zOrderProvider; + zOrder = layerZOrder; + SortMarkers(); + topMarker.onStartDrag += OnDragTopMarker; + } + + public override double start + { + get { return topMarker.start; } + } + + public override double end + { + get { return topMarker.end; } + } + + public override ITimelineItem item + { + get { return topMarker.item; } + } + + public override void Select() + { + foreach (var marker in m_MarkerGUIs) + { + if (!marker.IsSelected()) + marker.Select(); + } + } + + public override void Deselect() + { + foreach (var marker in m_MarkerGUIs) + { + if (marker.IsSelected()) + marker.Deselect(); + } + } + + public override void Draw(Rect trackRect, bool trackRectChanged, WindowState state) + { + RegisterRect(state); + + topMarker.Draw(trackRect, trackRectChanged, state); + + if (m_MarkerGUIs.Count > 1) + GUI.Box(treeViewRect, String.Empty, DirectorStyles.Instance.markerMultiOverlay); + + if (m_ManipulatedMarker != null) + m_ManipulatedMarker.Draw(trackRect, trackRectChanged, state); + } + + public override Rect RectToTimeline(Rect trackRect, WindowState state) + { + return topMarker.RectToTimeline(trackRect, state); + } + + public void CycleTop() + { + if (m_MarkerGUIs.Count < 2) + return; + + topMarker.onStartDrag -= OnDragTopMarker; + + var last = topMarker; + for (int i = 0; i < m_MarkerGUIs.Count; ++i) + { + var next = m_MarkerGUIs[i]; + m_MarkerGUIs[i] = last; + last = next; + } + + topMarker.zOrder = m_ZOrderProvider.Next(); + + topMarker.onStartDrag += OnDragTopMarker; + } + + void OnDragTopMarker() + { + m_ManipulatedMarker = topMarker; + m_ManipulatedMarker.onStartDrag -= OnDragTopMarker; + m_MarkerGUIs.RemoveAt(m_MarkerGUIs.Count - 1); + } + + void SortMarkers() + { + m_MarkerGUIs.Sort((lhs, rhs) => lhs.zOrder.CompareTo(rhs.zOrder)); + } + + void RegisterRect(WindowState state) + { + treeViewRect = topMarker.treeViewRect; + + if (Event.current.type == EventType.Repaint && !parent.locked) + state.spacePartitioner.AddBounds(this, rect); + } + + public static bool CanCycleMarkers() + { + if (!SelectionManager.SelectedMarkers().Any()) + return false; + + var cluster = PickerUtils.TopmostPickedItemOfType(); + + if (cluster == null) + return false; + + // Only cycle if the marker is selected and nothing else is selected + return cluster.topMarker.IsSelected() && SelectionManager.Count() == 1; + } + + public static void CycleMarkers() + { + var cluster = PickerUtils.TopmostPickedItemOfType(); + + if (cluster == null) + return; + + cluster.topMarker.Deselect(); + cluster.CycleTop(); + cluster.topMarker.Select(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineMarkerClusterGUI.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineMarkerClusterGUI.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..692661fe7ef5afcd9a1fe986ed75bf740279b4e8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineMarkerClusterGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2c03ae9aa36a4fd44a983831f44654be +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineMarkerGUI.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineMarkerGUI.cs new file mode 100644 index 0000000000000000000000000000000000000000..cb62e7629dce90144f3d1277004375bdd92ce58b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineMarkerGUI.cs @@ -0,0 +1,193 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Timeline; +using UnityObject = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class TimelineMarkerGUI : TimelineItemGUI, ISnappable, IAttractable + { + public event System.Action onStartDrag; + + int m_ProjectedClipHash; + int m_MarkerHash; + bool m_Selectable; + + MarkerDrawOptions m_MarkerDrawOptions; + MarkerEditor m_Editor; + + IMarker marker { get; } + + bool selectable + { + get { return m_Selectable; } + } + + public double time + { + get { return marker.time; } + } + + public override double start + { + get { return time; } + } + + public override double end + { + get { return time; } + } + + public override void Select() + { + zOrder = zOrderProvider.Next(); + SelectionManager.Add(marker); + TimelineWindowViewPrefs.GetTrackViewModelData(parent.asset).markerTimeStamps[m_MarkerHash] = DateTime.UtcNow.Ticks; + } + + public override bool IsSelected() + { + return SelectionManager.Contains(marker); + } + + public override void Deselect() + { + SelectionManager.Remove(marker); + } + + public override ITimelineItem item + { + get { return ItemsUtils.ToItem(marker); } + } + + IZOrderProvider zOrderProvider { get; } + + public TimelineMarkerGUI(IMarker theMarker, IRowGUI parent, IZOrderProvider provider) : base(parent) + { + marker = theMarker; + m_Selectable = marker.GetType().IsSubclassOf(typeof(UnityObject)); + + m_MarkerHash = 0; + var o = marker as object; + if (!o.Equals(null)) + m_MarkerHash = o.GetHashCode(); + + zOrderProvider = provider; + zOrder = zOrderProvider.Next(); + ItemToItemGui.Add(marker, this); + m_Editor = CustomTimelineEditorCache.GetMarkerEditor(theMarker); + } + + int ComputeDirtyHash() + { + return time.GetHashCode(); + } + + static void DrawMarker(Rect drawRect, Type type, bool isSelected, bool isCollapsed, MarkerDrawOptions options) + { + if (Event.current.type == EventType.Repaint) + { + bool hasError = !string.IsNullOrEmpty(options.errorText); + + var style = StyleManager.UssStyleForType(type); + style.Draw(drawRect, GUIContent.none, false, false, !isCollapsed, isSelected); + + // case1141836: Use of GUI.Box instead of GUI.Label causes desync in UI controlID + if (hasError) + GUI.Label(drawRect, String.Empty, DirectorStyles.Instance.markerWarning); + + var tooltip = hasError ? options.errorText : options.tooltip; + if (!string.IsNullOrEmpty(tooltip) && drawRect.Contains(Event.current.mousePosition)) + { + GUIStyle.SetMouseTooltip(tooltip, drawRect); + } + } + } + + void UpdateDrawData() + { + if (Event.current.type == EventType.Layout) + { + try + { + m_MarkerDrawOptions = m_Editor.GetMarkerOptions(marker); + } + catch (Exception e) + { + Debug.LogException(e); + m_MarkerDrawOptions = CustomTimelineEditorCache.GetDefaultMarkerEditor().GetMarkerOptions(marker); + } + } + } + + public override void Draw(Rect trackRect, bool trackRectChanged, WindowState state) + { + UpdateDrawData(); + + // compute marker hash + var currentMarkerHash = ComputeDirtyHash(); + + // update the clip projected rectangle on the timeline + CalculateClipRectangle(trackRect, state, currentMarkerHash, trackRectChanged); + + var isSelected = selectable && SelectionManager.Contains(marker); + var showMarkers = parent.showMarkers; + + QueueOverlay(treeViewRect, isSelected, !showMarkers); + DrawMarker(treeViewRect, marker.GetType(), isSelected, !showMarkers, m_MarkerDrawOptions); + + if (Event.current.type == EventType.Repaint && showMarkers && !parent.locked) + state.spacePartitioner.AddBounds(this, rect); + } + + public void QueueOverlay(Rect rect, bool isSelected, bool isCollapsed) + { + if (Event.current.type == EventType.Repaint && m_Editor.supportsDrawOverlay) + { + rect = GUIClip.Unclip(rect); + TimelineWindow.instance.AddUserOverlay(marker, rect, m_Editor, isCollapsed, isSelected); + } + } + + public override void StartDrag() + { + if (onStartDrag != null) + onStartDrag.Invoke(); + } + + void CalculateClipRectangle(Rect trackRect, WindowState state, int projectedClipHash, bool trackRectChanged) + { + if (m_ProjectedClipHash == projectedClipHash && !trackRectChanged) + return; + + m_ProjectedClipHash = projectedClipHash; + treeViewRect = RectToTimeline(trackRect, state); + } + + public override Rect RectToTimeline(Rect trackRect, WindowState state) + { + var style = StyleManager.UssStyleForType(marker.GetType()); + var width = style.fixedWidth; + var height = style.fixedHeight; + var x = ((float)marker.time * state.timeAreaScale.x) + state.timeAreaTranslation.x + trackRect.xMin; + x -= 0.5f * width; + return new Rect(x, trackRect.y, width, height); + } + + public IEnumerable SnappableEdgesFor(IAttractable attractable, ManipulateEdges manipulateEdges) + { + var edges = new List(); + var attractableGUI = attractable as TimelineMarkerGUI; + var canAddEdges = !(attractableGUI != null && attractableGUI.parent == parent); + if (canAddEdges) + edges.Add(new Edge(time)); + return edges; + } + + public bool ShouldSnapTo(ISnappable snappable) + { + return snappable != this; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineMarkerGUI.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineMarkerGUI.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..ecfff45ef9264150adb5cd50349604dc804869cd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ItemGui/TimelineMarkerGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8d34348f8b97a334291f5cf31adc5d67 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsClips.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsClips.cs new file mode 100644 index 0000000000000000000000000000000000000000..a2c7e4c5545f42446668104c3cf617283e0396fe --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsClips.cs @@ -0,0 +1,54 @@ +using UnityEditor.Timeline.Actions; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class DrillIntoClip : Manipulator + { + protected override bool DoubleClick(Event evt, WindowState state) + { + if (evt.button != 0) + return false; + + var guiClip = PickerUtils.TopmostPickedItem() as TimelineClipGUI; + + if (guiClip == null) + return false; + + if (!TimelineWindow.instance.state.editSequence.isReadOnly && (guiClip.clip.curves != null || guiClip.clip.animationClip != null)) + Invoker.Invoke(new[] {guiClip.clip}); + + if (guiClip.supportsSubTimelines) + Invoker.Invoke(new[] {guiClip.clip}); + + return true; + } + } + + class ContextMenuManipulator : Manipulator + { + protected override bool MouseDown(Event evt, WindowState state) + { + if (evt.button == 1) + ItemSelection.HandleSingleSelection(evt); + + return false; + } + + protected override bool ContextClick(Event evt, WindowState state) + { + if (evt.alt) + return false; + + var selectable = PickerUtils.TopmostPickedItem() as ISelectable; + + if (selectable != null && selectable.IsSelected()) + { + SequencerContextMenu.ShowItemContextMenu(evt.mousePosition); + return true; + } + + return false; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsClips.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsClips.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..c230e7877b3e8af92d533d485d109aae80a032e3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsClips.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b222f61a1f7253e4d8e8cc82bfde9e42 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsTimeline.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsTimeline.cs new file mode 100644 index 0000000000000000000000000000000000000000..d663f980b77a833c7d70ada2b61b633abd8ac59b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsTimeline.cs @@ -0,0 +1,274 @@ +using System; +using System.Linq; +using UnityEditor.ShortcutManagement; +using UnityEditor.Timeline.Actions; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class TimelinePanManipulator : Manipulator + { + const float k_MaxPanSpeed = 50.0f; + bool m_Active; + + protected override bool MouseDown(Event evt, WindowState state) + { + if ((evt.button == 2 && evt.modifiers == EventModifiers.None) || + (evt.button == 0 && evt.modifiers == EventModifiers.Alt)) + { + TimelineCursors.SetCursor(TimelineCursors.CursorType.Pan); + + m_Active = true; + return true; + } + + return false; + } + + protected override bool MouseUp(Event evt, WindowState state) + { + if (m_Active) + { + TimelineCursors.ClearCursor(); + state.editorWindow.Repaint(); + } + + return false; + } + + protected override bool MouseDrag(Event evt, WindowState state) + { + // Note: Do not rely on evt.button here as some 3rd party automation + // software does not properly set the button data during drag. + + if (!m_Active) + return false; + + return Pan(evt, state); + } + + protected override bool MouseWheel(Event evt, WindowState state) + { + if (Math.Abs(evt.delta.x) < 1e-5 || Math.Abs(evt.delta.x) <= Math.Abs(evt.delta.y)) + return false; + + TimelineZoomManipulator.InvalidateWheelZoom(); + + var panEvent = new Event(evt); + panEvent.delta = new Vector2(panEvent.delta.x * k_MaxPanSpeed * -1.0f, 0.0f); + + return Pan(panEvent, state); + } + + static bool Pan(Event evt, WindowState state) + { + var cursorRect = TimelineWindow.instance.sequenceContentRect; + cursorRect.xMax = TimelineWindow.instance.position.xMax; + cursorRect.yMax = TimelineWindow.instance.position.yMax; + + if (state.GetWindow() != null && state.GetWindow().treeView != null) + { + var scroll = state.GetWindow().treeView.scrollPosition; + scroll.y -= evt.delta.y; + state.GetWindow().treeView.scrollPosition = scroll; + state.OffsetTimeArea((int)evt.delta.x); + return true; + } + + return false; + } + } + + + class TimelineZoomManipulator : Manipulator + { + Vector2 m_MouseDownPos = Vector2.zero; + float m_FocalTime; + float m_LastMouseMoveX = -1; + bool m_WheelUsedLast; + + TimelineZoomManipulator() {} + + public static readonly TimelineZoomManipulator Instance = new TimelineZoomManipulator(); + + internal void DoZoom(float zoomFactor) + { + var refRange = TimelineEditor.visibleTimeRange; + DoZoom(zoomFactor, refRange, (refRange.x + refRange.y) / 2); + // Force resetting the reference zoom after a Framing operation + InvalidateWheelZoom(); + } + + static void DoZoom(float zoomFactor, Vector2 refRange, float focalTime) + { + const float kMinRange = 0.05f; // matches zoomable area. + + if (zoomFactor <= 0) + return; + + var t = Mathf.Max(focalTime, refRange.x); + var x =(refRange.x + t * (zoomFactor - 1)) / zoomFactor; + var y = (refRange.y + t * (zoomFactor - 1)) / zoomFactor; + + var newRange = Mathf.Abs(x - y) < kMinRange? refRange:new Vector2( + Mathf.Max(x, -WindowConstants.timeAreaShownRangePadding), + Mathf.Min(y, WindowState.kMaxShownTime)); + + if(newRange != refRange) + // Zoomable area does not protect 100% against crazy values + TimelineEditor.visibleTimeRange = newRange; + } + + internal static void InvalidateWheelZoom() + { + Instance.m_WheelUsedLast = false; + } + + protected override bool MouseDown(Event evt, WindowState state) + { + m_MouseDownPos = evt.mousePosition; + m_FocalTime = state.PixelToTime(m_MouseDownPos.x); + return false; + } + + protected override bool MouseWheel(Event evt, WindowState state) + { + if (Math.Abs(evt.delta.y) < 1e-5) + return false; + + var zoomRect = TimelineWindow.instance.sequenceContentRect; + zoomRect.yMax += TimelineWindow.instance.horizontalScrollbarHeight; + + if (!zoomRect.Contains(evt.mousePosition)) + return false; + + if (!m_WheelUsedLast || Mathf.Abs(m_LastMouseMoveX - evt.mousePosition.x) > 1.0f) + { + m_LastMouseMoveX = evt.mousePosition.x; + m_FocalTime = state.PixelToTime(m_LastMouseMoveX); + } + + var zoomFactor = -evt.delta.y * 0.02f + 1; + DoZoom(zoomFactor, state.timeAreaShownRange, m_FocalTime); + + m_WheelUsedLast = true; + return true; + } + + protected override bool MouseDrag(Event evt, WindowState state) + { + // Fast zoom... + if (evt.modifiers != EventModifiers.Alt || evt.button != 1) return false; + + var mouseMoveLength = Event.current.mousePosition - m_MouseDownPos; + var delta = Math.Abs(mouseMoveLength.x) > Math.Abs(mouseMoveLength.y) + ? mouseMoveLength.x + : -mouseMoveLength.y; + var zoomFactor = PixelToZoom(delta); + DoZoom(zoomFactor, state.timeAreaShownRange, m_FocalTime); + + m_WheelUsedLast = false; + return true; + } + + static float PixelToZoom(float x) + { + const float pixel2Zoom = 1 / 300.0f; + x *= pixel2Zoom; + if (x < -0.75) + { + // Rational function that behaves like 1+x on [-0.75,inf) and asymptotically reaches zero on (-inf,-0.75] + // The coefficients were obtained by the following constraints: + //1) f(-0.75) = 0.25 + //2) f'(-0.75) = 1 C1 continuity + //3) f(-3) = 0.001 (asymptotically zero) + return 1 / (98.6667f + 268.444f * x + 189.63f * x * x); + } + return 1 + x; + } + } + + class TimelineShortcutManipulator : Manipulator + { + protected override bool ValidateCommand(Event evt, WindowState state) + { + return evt.commandName == EventCommandNames.Copy || + evt.commandName == EventCommandNames.Paste || + evt.commandName == EventCommandNames.Duplicate || + evt.commandName == EventCommandNames.SelectAll || + evt.commandName == EventCommandNames.Delete || + evt.commandName == EventCommandNames.SoftDelete || + evt.commandName == EventCommandNames.FrameSelected; + } + + protected override bool ExecuteCommand(Event evt, WindowState state) + { + if (state.IsCurrentEditingASequencerTextField()) + return false; + + if (evt.commandName == EventCommandNames.SelectAll) + { + Invoker.InvokeWithSelected(); + return true; + } + + if (evt.commandName == EventCommandNames.SoftDelete) + { + Invoker.InvokeWithSelected(); + return true; + } + + if (evt.commandName == EventCommandNames.FrameSelected) + { + Invoker.InvokeWithSelected(); + return true; + } + + return ActionManager.HandleShortcut(evt); + } + } + + class InlineCurvesShortcutManipulator : Manipulator + { + protected override bool ExecuteCommand(Event evt, WindowState state) + { + if (state.IsCurrentEditingASequencerTextField()) + return false; + + var inlineCurveEditor = SelectionManager.GetCurrentInlineEditorCurve(); + if (inlineCurveEditor == null || !inlineCurveEditor.inlineCurvesSelected) + return false; + + if (evt.commandName != EventCommandNames.FrameSelected) + return false; + + Invoker.InvokeWithSelected(); + return true; + } + + // CurveEditor uses an hardcoded shortcut to execute the FrameAll action, preventing the ShortcutManager from + // ever picking it up. We have to hijack it to ensure our code is being run when framing inline curves. + protected override bool KeyDown(Event evt, WindowState state) + { + var inlineCurveEditor = SelectionManager.GetCurrentInlineEditorCurve(); + if (inlineCurveEditor == null || !inlineCurveEditor.inlineCurvesSelected) + return false; + + // Not conflicting with the hardcoded value + if (evt.keyCode != KeyCode.A) + return false; + + var combination = ShortcutManager.instance.GetShortcutBinding(Shortcuts.Timeline.frameAll) + .keyCombinationSequence.ToList(); + + var shortcutCombination = combination.First(); + var currentCombination = KeyCombination.FromKeyboardInput(evt); + + // User is not actually pressing the correct key combination for FrameAll + if (combination.Count == 1 && shortcutCombination.Equals(currentCombination)) + Invoker.InvokeWithSelected(); + + return true; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsTimeline.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsTimeline.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5612ca49bfb487122171d3d96fd04c466a122383 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsTimeline.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d029640460cf8ff47bbbfe69f49ddf29 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsTracks.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsTracks.cs new file mode 100644 index 0000000000000000000000000000000000000000..75b93001866289b978b76c9141bc2be41a404dd9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsTracks.cs @@ -0,0 +1,196 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEditor.Timeline.Actions; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class InlineCurveResize : Manipulator + { + bool m_Captured; + + float m_CapturedHeight; + float m_CaptureMouseYPos; + + InlineCurveResizeHandle m_Target; + + protected override bool MouseDown(Event evt, WindowState state) + { + m_Target = PickerUtils.FirstPickedElementOfType(); + if (m_Target == null) + return false; + + m_Captured = true; + m_CapturedHeight = TimelineWindowViewPrefs.GetInlineCurveHeight(m_Target.trackGUI.track); + m_CaptureMouseYPos = GUIUtility.GUIToScreenPoint(Event.current.mousePosition).y; + state.AddCaptured(this); + + return true; + } + + protected override bool MouseDrag(Event evt, WindowState state) + { + if (!m_Captured || m_Target == null) + return false; + + var trackGUI = m_Target.trackGUI; + + float inlineTrackHeight = m_CapturedHeight + + (GUIUtility.GUIToScreenPoint(Event.current.mousePosition).y - m_CaptureMouseYPos); + + TimelineWindowViewPrefs.SetInlineCurveHeight(trackGUI.track, Mathf.Max(inlineTrackHeight, 60.0f)); + + state.GetWindow().treeView.CalculateRowRects(); + + return true; + } + + protected override bool MouseUp(Event evt, WindowState state) + { + if (!m_Captured) + return false; + + state.RemoveCaptured(this); + m_Captured = false; + + return true; + } + + public override void Overlay(Event evt, WindowState state) + { + var rect = state.GetWindow().sequenceRect; + EditorGUIUtility.AddCursorRect(rect, MouseCursor.SplitResizeUpDown); + } + } + + class TrackResize : Manipulator + { + bool m_Captured; + int m_NumberOfContributingTracks; + + TrackResizeHandle m_Target; + List m_TracksToResize; + + protected override bool MouseDown(Event evt, WindowState state) + { + m_Target = PickerUtils.FirstPickedElementOfType(); + if (m_Target == null) + return false; + + m_NumberOfContributingTracks = 1; + var selectedTracks = SelectionManager.SelectedTrackGUI().ToList(); + + if (selectedTracks.Any() && selectedTracks.Contains(m_Target.trackGUI)) //resize all selected tracks + { + var allTrackGui = state.GetWindow().treeView.allTrackGuis; + m_TracksToResize = allTrackGui.OfType().Where(i => SelectionManager.Contains(i.track)).ToList(); + m_NumberOfContributingTracks += m_TracksToResize.IndexOf(m_Target.trackGUI); + } + else + m_TracksToResize = new List { m_Target.trackGUI }; + + m_Captured = true; + state.AddCaptured(this); + + return true; + } + + protected override bool MouseDrag(Event evt, WindowState state) + { + if (!m_Captured || m_Target == null) + return false; + + var delta = evt.mousePosition.y - m_Target.boundingRect.center.y; + var extension = Mathf.RoundToInt(delta / m_NumberOfContributingTracks / state.trackScale); + foreach (var track in m_TracksToResize) + track.heightExtension += extension; + + state.GetWindow().treeView.CalculateRowRects(); + return true; + } + + protected override bool MouseUp(Event evt, WindowState state) + { + if (!m_Captured) + return false; + + foreach (var track in m_TracksToResize) + CommitExtension(track); + + state.GetWindow().treeView.CalculateRowRects(); + state.RemoveCaptured(this); + m_Captured = false; + + return true; + } + + public override void Overlay(Event evt, WindowState state) + { + var rect = state.GetWindow().sequenceRect; + EditorGUIUtility.AddCursorRect(rect, MouseCursor.SplitResizeUpDown); + } + + static void CommitExtension(TimelineTrackGUI trackGUI) + { + if (trackGUI != null) + TimelineWindowViewPrefs.SetTrackHeightExtension(trackGUI.track, trackGUI.heightExtension); + } + } + + class TrackDoubleClick : Manipulator + { + protected override bool DoubleClick(Event evt, WindowState state) + { + if (evt.button != 0) + return false; + + var trackGUI = PickerUtils.FirstPickedElementOfType(); + + if (trackGUI == null) + return false; + + // Double-click is only available for AnimationTracks: it conflicts with selection mechanics on other tracks + if ((trackGUI.track as AnimationTrack) == null) + return false; + + return EditTrackInAnimationWindow.Do(trackGUI.track); + } + } + + class TrackShortcutManipulator : Manipulator + { + protected override bool KeyDown(Event evt, WindowState state) + { + return InternalExecute(evt, state); + } + + protected override bool ExecuteCommand(Event evt, WindowState state) + { + return InternalExecute(evt, state); + } + + static bool InternalExecute(Event evt, WindowState state) + { + if (state.IsCurrentEditingASequencerTextField()) + return false; + + var tracks = SelectionManager.SelectedTracks().ToList(); + var items = SelectionManager.SelectedClipGUI(); + + foreach (var item in items) + { + var trackGUI = item.parent as TimelineTrackBaseGUI; + if (trackGUI == null) + continue; + + if (!tracks.Contains(trackGUI.track)) + tracks.Add(trackGUI.track); + } + + return ActionManager.HandleShortcut(evt, + ActionManager.TrackActions, + x => ActionManager.ExecuteTrackAction(x, tracks)); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsTracks.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsTracks.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..cfbbb313e4f5b118b6642a9acb7d4e0cf4817554 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/ManipulationsTracks.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5151708d47edd4344ba8e7bd469d966e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Manipulator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Manipulator.cs new file mode 100644 index 0000000000000000000000000000000000000000..d0aac157a14ba2db5e6c0e76dfcc217fe5dc48b6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Manipulator.cs @@ -0,0 +1,91 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + abstract class Manipulator + { + int m_Id; + + protected virtual bool MouseDown(Event evt, WindowState state) { return false; } + protected virtual bool MouseDrag(Event evt, WindowState state) { return false; } + protected virtual bool MouseWheel(Event evt, WindowState state) { return false; } + protected virtual bool MouseUp(Event evt, WindowState state) { return false; } + protected virtual bool DoubleClick(Event evt, WindowState state) { return false; } + protected virtual bool KeyDown(Event evt, WindowState state) { return false; } + protected virtual bool KeyUp(Event evt, WindowState state) { return false; } + protected virtual bool ContextClick(Event evt, WindowState state) { return false; } + protected virtual bool ValidateCommand(Event evt, WindowState state) { return false; } + protected virtual bool ExecuteCommand(Event evt, WindowState state) { return false; } + + public virtual void Overlay(Event evt, WindowState state) {} + + public bool HandleEvent(WindowState state) + { + if (m_Id == 0) + m_Id = GUIUtility.GetPermanentControlID(); + + bool isHandled = false; + var evt = Event.current; + + switch (evt.GetTypeForControl(m_Id)) + { + case EventType.ScrollWheel: + isHandled = MouseWheel(evt, state); + break; + + case EventType.MouseUp: + { + if (GUIUtility.hotControl == m_Id) + { + isHandled = MouseUp(evt, state); + + GUIUtility.hotControl = 0; + evt.Use(); + } + } + break; + + case EventType.MouseDown: + { + isHandled = evt.clickCount < 2 ? MouseDown(evt, state) : DoubleClick(evt, state); + + if (isHandled) + GUIUtility.hotControl = m_Id; + } + break; + + case EventType.MouseDrag: + { + if (GUIUtility.hotControl == m_Id) + isHandled = MouseDrag(evt, state); + } + break; + + case EventType.KeyDown: + isHandled = KeyDown(evt, state); + break; + + case EventType.KeyUp: + isHandled = KeyUp(evt, state); + break; + + case EventType.ContextClick: + isHandled = ContextClick(evt, state); + break; + + case EventType.ValidateCommand: + isHandled = ValidateCommand(evt, state); + break; + + case EventType.ExecuteCommand: + isHandled = ExecuteCommand(evt, state); + break; + } + + if (isHandled) + evt.Use(); + + return isHandled; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Manipulator.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Manipulator.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..9676bc002b3bc35c39ea5014566c3b84cae65604 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Manipulator.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2bf68308f6cdff141ab98cd34174e4f1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/PickerUtils.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/PickerUtils.cs new file mode 100644 index 0000000000000000000000000000000000000000..e3611a4298776d57f267cce2f709972c1a696226 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/PickerUtils.cs @@ -0,0 +1,56 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + static class PickerUtils + { + public static List pickedElements { get; private set; } + + public static void DoPick(WindowState state, Vector2 mousePosition) + { + if (state.GetWindow().sequenceHeaderRect.Contains(mousePosition)) + { + pickedElements = state.headerSpacePartitioner.GetItemsAtPosition(mousePosition).ToList(); + } + else if (state.GetWindow().sequenceContentRect.Contains(mousePosition)) + { + pickedElements = state.spacePartitioner.GetItemsAtPosition(mousePosition).ToList(); + } + else + { + if (pickedElements != null) + pickedElements.Clear(); + else + pickedElements = new List(); + } + } + + public static ILayerable TopmostPickedItem() + { + return PickedItemsSortedByZOrderOfType().FirstOrDefault(); + } + + public static T TopmostPickedItemOfType() where T : class, ILayerable + { + return PickedItemsSortedByZOrderOfType().FirstOrDefault(); + } + + public static T TopmostPickedItemOfType(Func predicate) where T : class, ILayerable + { + return PickedItemsSortedByZOrderOfType().FirstOrDefault(predicate); + } + + static IEnumerable PickedItemsSortedByZOrderOfType() where T: class, ILayerable + { + return pickedElements.OfType().OrderByDescending(x => x.zOrder); + } + + public static T FirstPickedElementOfType() where T : class, IBounds + { + return pickedElements.FirstOrDefault(e => e is T) as T; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/PickerUtils.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/PickerUtils.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..829ef0a9d628f4450437bbe7ac1dd5dd2b6932f0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/PickerUtils.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 16950289b516d6747868e0f7bf7b37a0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping.meta new file mode 100644 index 0000000000000000000000000000000000000000..bb822d5a4f147de0755eeaddbf94a53707381876 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 06ae1baf5524b314fa65b173b9eca869 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/IAttractable.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/IAttractable.cs new file mode 100644 index 0000000000000000000000000000000000000000..772809dfb2d7513679f65d131e6ac2ddd07856d5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/IAttractable.cs @@ -0,0 +1,21 @@ +namespace UnityEditor.Timeline +{ + enum AttractedEdge + { + None, + Left, + Right + } + + interface IAttractable + { + bool ShouldSnapTo(ISnappable snappable); + double start { get; } + double end { get; } + } + + interface IAttractionHandler + { + void OnAttractedEdge(IAttractable attractable, ManipulateEdges manipulateEdges, AttractedEdge edge, double time); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/IAttractable.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/IAttractable.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..570a8b9d768342c6bc5cdcc1a718bca6f8b30e94 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/IAttractable.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6bfec54ce89b0b642a65d44def023b99 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/ISnappable.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/ISnappable.cs new file mode 100644 index 0000000000000000000000000000000000000000..52a17a658b332430d0721aa87248388af9cdad67 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/ISnappable.cs @@ -0,0 +1,22 @@ +using System.Collections.Generic; + +namespace UnityEditor.Timeline +{ + struct Edge + { + public double time { get; set; } + + public bool showSnapHint { get; set; } + + public Edge(double edgeTime, bool snapHint = true) : this() + { + time = edgeTime; + showSnapHint = snapHint; + } + } + + interface ISnappable + { + IEnumerable SnappableEdgesFor(IAttractable attractable, ManipulateEdges manipulateEdges); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/ISnappable.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/ISnappable.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..dccc3e291e47e5e308fd057441fc052eaa42335f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/ISnappable.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3664a2ade19bb7848a4d2c96ac9148e3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/SnapEngine.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/SnapEngine.cs new file mode 100644 index 0000000000000000000000000000000000000000..351eda8c5a586e721b47fe930643cbf95f5aefda --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/SnapEngine.cs @@ -0,0 +1,288 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + enum ManipulateEdges + { + Left, + Right, + Both + } + + class SnapEngine + { + static readonly float k_MagnetInfluenceInPixels = 10.0f; + + class SnapInfo + { + public double time { get; set; } + + public bool showSnapHint { get; set; } + + public bool IsInInfluenceZone(double currentTime, WindowState state) + { + var pos = state.TimeToPixel(currentTime); + var magnetPos = state.TimeToPixel(time); + + return Math.Abs(pos - magnetPos) < k_MagnetInfluenceInPixels; + } + } + + struct TimeBoundaries + { + public TimeBoundaries(double l, double r) + { + left = l; + right = r; + } + + public readonly double left; + public readonly double right; + + public TimeBoundaries Translate(double d) + { + return new TimeBoundaries(left + d, right + d); + } + } + + public static bool displayDebugLayout; + + readonly IAttractable m_Attractable; + readonly IAttractionHandler m_AttractionHandler; + readonly ManipulateEdges m_ManipulateEdges; + + readonly WindowState m_State; + + double m_GrabbedTime; + TimeBoundaries m_GrabbedTimes; + + TimeBoundaries m_CurrentTimes; + + readonly List m_Magnets = new List(); + + bool m_SnapEnabled; + + public SnapEngine(IAttractable attractable, IAttractionHandler attractionHandler, ManipulateEdges manipulateEdges, WindowState state, + Vector2 mousePosition, IEnumerable snappables = null) + { + m_Attractable = attractable; + m_ManipulateEdges = manipulateEdges; + + m_AttractionHandler = attractionHandler; + m_State = state; + + m_CurrentTimes = m_GrabbedTimes = new TimeBoundaries(m_Attractable.start, m_Attractable.end); + m_GrabbedTime = m_State.PixelToTime(mousePosition.x); + + // Add Time zero as Magnet + AddMagnet(0.0, true, state); + + // Add current Time as Magnet + // case1157280 only add current time as magnet if visible + if (TimelineWindow.instance.currentMode.ShouldShowTimeCursor(m_State)) + AddMagnet(state.editSequence.time, true, state); + + if (state.IsEditingASubTimeline()) + { + // Add start and end of evaluable range as Magnets + // This includes the case where the master timeline has a fixed length + var range = state.editSequence.GetEvaluableRange(); + AddMagnet(range.start, true, state); + AddMagnet(range.end, true, state); + } + else if (state.masterSequence.asset.durationMode == TimelineAsset.DurationMode.FixedLength) + { + // Add end sequence Time as Magnet + AddMagnet(state.masterSequence.asset.duration, true, state); + } + + + if (snappables == null) + snappables = GetVisibleSnappables(m_State); + + foreach (var snappable in snappables) + { + if (!attractable.ShouldSnapTo(snappable)) + continue; + + var edges = snappable.SnappableEdgesFor(attractable, manipulateEdges); + foreach (var edge in edges) + AddMagnet(edge.time, edge.showSnapHint, state); + } + } + + public static IEnumerable GetVisibleSnappables(WindowState state) + { + Rect rect = TimelineWindow.instance.state.timeAreaRect; + rect.height = float.MaxValue; + return state.spacePartitioner.GetItemsInArea(rect).ToArray(); + } + + void AddMagnet(double magnetTime, bool showSnapHint, WindowState state) + { + var magnet = m_Magnets.FirstOrDefault(m => m.time.Equals(magnetTime)); + if (magnet == null) + { + if (IsMagnetInShownArea(magnetTime, state)) + m_Magnets.Add(new SnapInfo { time = magnetTime, showSnapHint = showSnapHint }); + } + else + { + magnet.showSnapHint |= showSnapHint; + } + } + + static bool IsMagnetInShownArea(double time, WindowState state) + { + var shownArea = state.timeAreaShownRange; + return time >= shownArea.x && time <= shownArea.y; + } + + SnapInfo GetMagnetAt(double time) + { + return m_Magnets.FirstOrDefault(m => m.time.Equals(time)); + } + + SnapInfo ClosestMagnet(double time) + { + SnapInfo candidate = null; + var min = double.MaxValue; + foreach (var magnetInfo in m_Magnets) + { + var m = Math.Abs(magnetInfo.time - time); + if (m < min) + { + candidate = magnetInfo; + min = m; + } + } + + if (candidate != null && candidate.IsInInfluenceZone(time, m_State)) + return candidate; + + return null; + } + + public void Snap(Vector2 currentMousePosition, EventModifiers modifiers) + { + var d = m_State.PixelToTime(currentMousePosition.x) - m_GrabbedTime; + + m_CurrentTimes = m_GrabbedTimes.Translate(d); + + bool isLeft = m_ManipulateEdges == ManipulateEdges.Left || m_ManipulateEdges == ManipulateEdges.Both; + bool isRight = m_ManipulateEdges == ManipulateEdges.Right || m_ManipulateEdges == ManipulateEdges.Both; + + bool attracted = false; + + m_SnapEnabled = modifiers == ManipulatorsUtils.actionModifier ? !m_State.edgeSnaps : m_State.edgeSnaps; + + if (m_SnapEnabled) + { + SnapInfo leftActiveMagnet = null; + SnapInfo rightActiveMagnet = null; + + if (isLeft) + leftActiveMagnet = ClosestMagnet(m_CurrentTimes.left); + + if (isRight) + rightActiveMagnet = ClosestMagnet(m_CurrentTimes.right); + + if (leftActiveMagnet != null || rightActiveMagnet != null) + { + attracted = true; + + bool leftAttraction = false; + + if (rightActiveMagnet == null) + { + // Attracted by a left magnet only. + leftAttraction = true; + } + else + { + if (leftActiveMagnet != null) + { + // Attracted by both magnets, choose the closest one. + var leftDistance = Math.Abs(leftActiveMagnet.time - m_CurrentTimes.left); + var rightDistance = Math.Abs(rightActiveMagnet.time - m_CurrentTimes.right); + + leftAttraction = leftDistance <= rightDistance; + } + // else, Attracted by right magnet only + } + + if (leftAttraction) + { + m_AttractionHandler.OnAttractedEdge(m_Attractable, m_ManipulateEdges, AttractedEdge.Left, leftActiveMagnet.time); + } + else + { + m_AttractionHandler.OnAttractedEdge(m_Attractable, m_ManipulateEdges, AttractedEdge.Right, rightActiveMagnet.time); + } + } + } + + if (!attracted) + { + var time = isLeft ? m_CurrentTimes.left : m_CurrentTimes.right; + + time = TimeReferenceUtility.SnapToFrameIfRequired(time); + + m_AttractionHandler.OnAttractedEdge(m_Attractable, m_ManipulateEdges, AttractedEdge.None, time); + } + } + + public void OnGUI(bool showLeft = true, bool showRight = true) + { + if (displayDebugLayout) + { + // Display Magnet influence zone + foreach (var m in m_Magnets) + { + var window = TimelineWindow.instance; + var rect = new Rect(m_State.TimeToPixel(m.time) - k_MagnetInfluenceInPixels, window.state.timeAreaRect.yMax, 2f * k_MagnetInfluenceInPixels, m_State.windowHeight); + EditorGUI.DrawRect(rect, new Color(1f, 0f, 0f, 0.4f)); + } + + // Display Cursor position + var mousePos = Event.current.mousePosition; + var time = m_State.PixelToTime(mousePos.x); + var p = new Vector2(m_State.TimeToPixel(time), TimelineWindow.instance.state.timeAreaRect.yMax); + var s = new Vector2(1f, m_State.windowHeight); + EditorGUI.DrawRect(new Rect(p, s), Color.blue); + + p = new Vector2(m_State.TimeToPixel(m_GrabbedTime), TimelineWindow.instance.state.timeAreaRect.yMax); + s = new Vector2(1f, m_State.windowHeight); + EditorGUI.DrawRect(new Rect(p, s), Color.red); + + p = new Vector2(m_State.TimeToPixel(m_CurrentTimes.left), TimelineWindow.instance.state.timeAreaRect.yMax); + s = new Vector2(1f, m_State.windowHeight); + EditorGUI.DrawRect(new Rect(p, s), Color.yellow); + + p = new Vector2(m_State.TimeToPixel(m_CurrentTimes.right), TimelineWindow.instance.state.timeAreaRect.yMax); + EditorGUI.DrawRect(new Rect(p, s), Color.yellow); + } + + if (m_SnapEnabled) + { + if (showLeft) + DrawMagnetLineAt(m_Attractable.start); + + if (showRight) + DrawMagnetLineAt(m_Attractable.end); + } + } + + void DrawMagnetLineAt(double time) + { + var magnet = GetMagnetAt(time); + + if (magnet != null && magnet.showSnapHint) + Graphics.DrawLineAtTime(m_State, magnet.time, Color.white); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/SnapEngine.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/SnapEngine.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a2ce57d6288b2df74b7a6d3c557ac39967a2ad62 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/Snapping/SnapEngine.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 48967a2d5427ac2489cc0ea61da5f1a0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineClipHandle.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineClipHandle.cs new file mode 100644 index 0000000000000000000000000000000000000000..6bd223859321894ceee0a140a7bee2a1b4b3ac8c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineClipHandle.cs @@ -0,0 +1,53 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class TimelineClipHandle : ILayerable + { + Rect m_Rect; + readonly TimelineClipGUI m_ClipGUI; + readonly TrimEdge m_TrimDirection; + readonly LayerZOrder m_ZOrder; + + public Rect boundingRect + { + get { return m_ClipGUI.parent.ToWindowSpace(m_Rect); } + } + + public TrimEdge trimDirection + { + get { return m_TrimDirection; } + } + + public TimelineClipGUI clipGUI + { + get { return m_ClipGUI; } + } + + public LayerZOrder zOrder + { + get { return m_ZOrder; } + } + + public TimelineClipHandle(TimelineClipGUI theClipGUI, TrimEdge trimDirection) + { + m_TrimDirection = trimDirection; + m_ClipGUI = theClipGUI; + m_ZOrder = theClipGUI.zOrder.ChangeLayer(Layer.ClipHandles); + } + + public void Draw(Rect clientRect, float width, WindowState state) + { + var handleRect = clientRect; + handleRect.width = width; + + if (m_TrimDirection == TrimEdge.End) + handleRect.x = clientRect.xMax - width; + + m_Rect = handleRect; + if (!TimelineWindow.instance.state.editSequence.isReadOnly) + EditorGUIUtility.AddCursorRect(handleRect, MouseCursor.SplitResizeLeftRight); + state.spacePartitioner.AddBounds(this, boundingRect); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineClipHandle.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineClipHandle.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..df0e0415dcdf3f27354f095716dbc3fd9686a3a7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineClipHandle.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3e29cdd1646803545b8fb18908666ec4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineClipUnion.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineClipUnion.cs new file mode 100644 index 0000000000000000000000000000000000000000..4288992663b9f6180bbb73d702034e7021be57e4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineClipUnion.cs @@ -0,0 +1,126 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEditorInternal; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class TimelineClipUnion + { + List m_Members = new List(); + Rect m_BoundingRect; + Rect m_Union; + double m_Start; + double m_Duration; + bool m_InitUnionRect = true; + + void Add(TimelineClipGUI clip) + { + m_Members.Add(clip); + if (m_Members.Count == 1) + { + m_BoundingRect = clip.clippedRect; + } + else + { + m_BoundingRect = Encompass(m_BoundingRect, clip.rect); + } + } + + public void Draw(Rect parentRect, WindowState state) + { + if (m_InitUnionRect) + { + m_Start = m_Members.OrderBy(c => c.clip.start).First().clip.start; + m_Duration = m_Members.Sum(c => c.clip.duration); + m_InitUnionRect = false; + } + + m_Union = new Rect((float)(m_Start) * state.timeAreaScale.x, 0, (float)m_Duration * state.timeAreaScale.x, 0); + + // transform clipRect into pixel-space + m_Union.xMin += state.timeAreaTranslation.x + parentRect.x; + m_Union.xMax += state.timeAreaTranslation.x + parentRect.x; + m_Union.y = parentRect.y + 4.0f; + m_Union.height = parentRect.height - 8.0f; + + // calculate clipped rect + if (m_Union.x < parentRect.xMin) + { + var overflow = parentRect.xMin - m_Union.x; + m_Union.x = parentRect.xMin; + m_Union.width -= overflow; + } + + // bail out if completely clipped + if (m_Union.xMax < parentRect.xMin) + return; + if (m_Union.xMin > parentRect.xMax) + return; + + EditorGUI.DrawRect(m_Union, DirectorStyles.Instance.customSkin.colorClipUnion); + } + + public static List Build(List clips) + { + var unions = new List(); + if (clips == null) + return unions; + + TimelineClipUnion currentUnion = null; + foreach (var c in clips) + { + if (currentUnion == null) + { + currentUnion = new TimelineClipUnion(); + currentUnion.Add(c); + unions.Add(currentUnion); + } + else + { + Rect result; + if (Intersection(c.rect, currentUnion.m_BoundingRect, out result)) + { + currentUnion.Add(c); + } + else + { + currentUnion = new TimelineClipUnion(); + currentUnion.Add(c); + unions.Add(currentUnion); + } + } + } + + return unions; + } + + public static Rect Encompass(Rect a, Rect b) + { + Rect newRect = a; + newRect.xMin = Mathf.Min(a.xMin, b.xMin); + newRect.yMin = Mathf.Min(a.yMin, b.yMin); + newRect.xMax = Mathf.Max(a.xMax, b.xMax); + newRect.yMax = Mathf.Max(a.yMax, b.yMax); + return newRect; + } + + public static bool Intersection(Rect r1, Rect r2, out Rect intersection) + { + if (!r1.Overlaps(r2) && !r2.Overlaps(r1)) + { + intersection = new Rect(0, 0, 0, 0); + return false; + } + + float left = Mathf.Max(r1.xMin, r2.xMin); + float top = Mathf.Max(r1.yMin, r2.yMin); + + float right = Mathf.Min(r1.xMax, r2.xMax); + float bottom = Mathf.Min(r1.yMax, r2.yMax); + + intersection = new Rect(left, top, right - left, bottom - top); + return true; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineClipUnion.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineClipUnion.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..86b5654321398f82123cf7f838c7bd6dd925a016 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineClipUnion.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: dc99dfeec967f2644b25dd6bace59b7e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineDataSource.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineDataSource.cs new file mode 100644 index 0000000000000000000000000000000000000000..94a88291fc561010d782869d416cd629f6fedfaf --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineDataSource.cs @@ -0,0 +1,223 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.IMGUI.Controls; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TimelineDataSource : TreeViewDataSource + { + readonly TimelineWindow m_TimelineWindow; + readonly TimelineTreeViewGUI m_ParentGUI; + + public List allTrackGuis { get; private set; } + + TreeViewItem treeroot + { + get { return m_RootItem; } + } + + public TimelineDataSource(TimelineTreeViewGUI parentGUI, TreeViewController treeView, TimelineWindow sequencerWindow) + : base(treeView) + { + m_TreeView.useExpansionAnimation = false; + m_TimelineWindow = sequencerWindow; + m_ParentGUI = parentGUI; + FetchData(); + } + + public override bool IsExpanded(TreeViewItem item) + { + if (!IsExpandable(item)) + return true; + + return IsExpanded(item.id); + } + + public override bool IsExpandable(TreeViewItem item) + { + var expandable = false; + + var track = item as TimelineTrackBaseGUI; + + if (track != null) + expandable = track.expandable; + + return expandable && item.hasChildren; + } + + public sealed override void FetchData() + { + // create root item + m_RootItem = new TimelineGroupGUI(m_TreeView, m_ParentGUI, 1, 0, null, "root", null, true); + + var tree = new Dictionary(); + + var filteredView = m_TimelineWindow.state.editSequence.asset.trackObjects; + allTrackGuis = new List(filteredView.Count()); + + foreach (var t in filteredView) + { + CreateItem(t, ref tree, filteredView.OfType(), m_RootItem); + } + + m_NeedRefreshRows = true; + + SetExpanded(m_RootItem, true); + } + + TimelineTrackBaseGUI CreateItem(ScriptableObject scriptableObject, ref Dictionary tree, IEnumerable selectedRows, TreeViewItem parentTreeViewItem) + { + // if a script doesn't load correctly, the trackAsset will be NULL, but the scriptableObject __should_ be intact (but == null will be true) + var trackAsset = scriptableObject as TrackAsset; + + if (tree == null) + throw new ArgumentNullException("tree"); + + if (selectedRows == null) + throw new ArgumentNullException("selectedRows"); + + if (trackAsset != null && tree.ContainsKey(trackAsset)) + return tree[trackAsset]; + + TimelineTrackBaseGUI parentItem = parentTreeViewItem as TimelineTrackBaseGUI; + + // should we create the parent? + TrackAsset parentTrack = trackAsset != null ? (trackAsset.parent as TrackAsset) : null; + if (trackAsset != null && parentTrack != null && selectedRows.Contains(parentTrack)) + { + parentItem = CreateItem(parentTrack, ref tree, selectedRows, parentTreeViewItem); + } + + int theDepth = -1; + if (parentItem != null) + theDepth = parentItem.depth; + theDepth++; + + TimelineTrackBaseGUI newItem; + if (trackAsset == null) + { + PlayableAsset parent = m_TimelineWindow.state.editSequence.asset; + if (parentItem != null && parentItem.track != null) + parent = parentItem.track; + + newItem = new TimelineTrackErrorGUI(m_TreeView, m_ParentGUI, 0, theDepth, parentItem, "ERROR", scriptableObject, parent); + } + else if (trackAsset.GetType() != typeof(GroupTrack)) + { + newItem = new TimelineTrackGUI(m_TreeView, m_ParentGUI, trackAsset.GetInstanceID(), theDepth, parentItem, trackAsset.name, trackAsset); + } + else + { + newItem = new TimelineGroupGUI(m_TreeView, m_ParentGUI, trackAsset.GetInstanceID(), theDepth, parentItem, trackAsset.name, trackAsset, false); + } + + allTrackGuis.Add(newItem); + + if (parentItem != null) + { + if (parentItem.children == null) + parentItem.children = new List(); + parentItem.children.Add(newItem); + SetExpanded(newItem, trackAsset.GetCollapsed()); + } + else + { + m_RootItem = newItem; + SetExpanded(m_RootItem, true); + } + + if (trackAsset != null) + tree[trackAsset] = newItem; + + var actorAsAnimTrack = newItem.track as AnimationTrack; + bool isEditableInfiniteClip = actorAsAnimTrack != null && actorAsAnimTrack.ShouldShowInfiniteClipEditor(); + if (isEditableInfiniteClip) + { + if (newItem.children == null) + newItem.children = new List(); + } + else if (trackAsset != null) + { + // check if clips on this track have animation, if so we inline a animationEditorTrack + bool clipHasAnimatableAnimationCurves = false; + + for (var i = 0; i != newItem.track.clips.Length; ++i) + { + var curveClip = newItem.track.clips[i].curves; + var animationClip = newItem.track.clips[i].animationClip; + + // prune out clip with zero curves + if (curveClip != null && curveClip.empty) + curveClip = null; + + if (animationClip != null && animationClip.empty) + animationClip = null; + + // prune out clips coming from FBX + if (animationClip != null && ((animationClip.hideFlags & HideFlags.NotEditable) != 0)) + animationClip = null; + + if (!newItem.track.clips[i].recordable) + animationClip = null; + + clipHasAnimatableAnimationCurves = (curveClip != null) || (animationClip != null); + if (clipHasAnimatableAnimationCurves) + break; + } + + if (clipHasAnimatableAnimationCurves) + { + if (newItem.children == null) + newItem.children = new List(); + } + } + + if (trackAsset != null) + { + // Here we are using the internal subTrackObject so we can properly handle tracks whose script + // can't load (via ScriptableObject) + foreach (var subTrack in trackAsset.subTracksObjects) + { + CreateItem(subTrack, ref tree, selectedRows, newItem); + } + } + return newItem; + } + + public override bool CanBeParent(TreeViewItem item) + { + // will prevent track becoming subtracks via dragging + TimelineTrackGUI track = item as TimelineTrackGUI; + if (track != null) + return false; + + return true; + } + + public void ExpandItems(TreeViewItem item) + { + if (treeroot == item) + { + SetExpanded(treeroot, true); + } + + TimelineGroupGUI gui = item as TimelineGroupGUI; + if (gui != null && gui.track != null) + { + SetExpanded(item, !gui.track.GetCollapsed()); + } + + if (item.children != null) + { + for (int c = 0; c < item.children.Count; c++) + { + ExpandItems(item.children[c]); + } + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineDataSource.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineDataSource.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5d40d2d39b6373bfccb2cf2424da48c8809e8c6b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineDataSource.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e8c30efa89029e447b0dc0efc75b294c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineDragging.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineDragging.cs new file mode 100644 index 0000000000000000000000000000000000000000..7d783f45033c4fe2e30be2bf67e4a87d7c7ecb9e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineDragging.cs @@ -0,0 +1,684 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.IMGUI.Controls; +using UnityEditor.Timeline; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.Playables; +using UnityObject = UnityEngine.Object; + +namespace UnityEditor +{ + class TimelineDragging : TreeViewDragging + { + public delegate bool TypeResolver(IEnumerable types, Action onComplete, string format); + + private static readonly string k_SelectTrackWithBinding = L10n.Tr("Add {0}"); + private static readonly string k_SelectTrackWithClip = L10n.Tr("Add Clip With {0}"); + private static readonly string k_SelectClip = L10n.Tr("Add {0}"); + + + const string k_GenericDragId = "TimelineDragging"; + readonly int kDragSensitivity = 2; + readonly TimelineAsset m_Timeline; + readonly TimelineWindow m_Window; + + class TimelineDragData + { + public TimelineDragData(List draggedItems) + { + this.draggedItems = draggedItems; + } + + public readonly List draggedItems; + } + + public TimelineDragging(TreeViewController treeView, TimelineWindow window, TimelineAsset data) + : base(treeView) + { + m_Timeline = data; + m_Window = window; + } + + public override bool CanStartDrag(TreeViewItem targetItem, List draggedItemIDs, Vector2 mouseDownPosition) + { + if (Event.current.modifiers != EventModifiers.None) + return false; + + // Can only drag when starting in the track header area + if (mouseDownPosition.x > m_Window.sequenceHeaderRect.xMax) + return false; + + var trackBaseGUI = targetItem as TimelineTrackBaseGUI; + + if (trackBaseGUI == null || trackBaseGUI.track == null) + return false; + + if (trackBaseGUI.track.lockedInHierarchy) + return false; + + if (Event.current.type == EventType.MouseDrag && Mathf.Abs(Event.current.delta.y) < kDragSensitivity) + return false; + + // Make sure dragged items are selected + // TODO Use similar system than the SceneHierarchyWindow in order to handle selection between treeView and tracks. + SelectionManager.Clear(); + var draggedTrackGUIs = m_Window.allTracks.Where(t => draggedItemIDs.Contains(t.id)); + foreach (var trackGUI in draggedTrackGUIs) + SelectionManager.Add(trackGUI.track); + + return true; + } + + public override void StartDrag(TreeViewItem draggedNode, List draggedItemIDs) + { + DragAndDrop.PrepareStartDrag(); + var tvItems = SelectionManager.SelectedTrackGUI().Cast().ToList(); + DragAndDrop.SetGenericData(k_GenericDragId, new TimelineDragData(tvItems)); + DragAndDrop.objectReferences = new UnityObject[] {}; // this IS required for dragging to work + + string title = draggedItemIDs.Count + (draggedItemIDs.Count > 1 ? "s" : ""); // title is only shown on OSX (at the cursor) + + TimelineGroupGUI groupGui = draggedNode as TimelineGroupGUI; + if (groupGui != null) + { + title = groupGui.displayName; + } + DragAndDrop.StartDrag(title); + } + + public static bool IsDraggingEvent() + { + return Event.current.type == EventType.DragUpdated || + Event.current.type == EventType.DragExited || + Event.current.type == EventType.DragPerform; + } + + public static bool ResolveType(IEnumerable types, Action onComplete, string formatString) + { + if (!types.Any() || onComplete == null) + return false; + + if (types.Count() == 1) + { + onComplete(types.First()); + return true; + } + + var menu = new GenericMenu(); + + var builtInTypes = types.Where(TypeUtility.IsBuiltIn).OrderBy(TypeUtility.GetDisplayName).ToArray(); + var customTypes = types.Where(x => !TypeUtility.IsBuiltIn(x)).OrderBy(TypeUtility.GetDisplayName).ToArray(); + + foreach (var t in builtInTypes) + { + menu.AddItem(new GUIContent(string.Format(formatString, TypeUtility.GetDisplayName(t))), false, s => onComplete((System.Type)s), t); + } + + if (builtInTypes.Length != 0 && customTypes.Length != 0) + menu.AddSeparator(string.Empty); + + foreach (var t in customTypes) + { + menu.AddItem(new GUIContent(string.Format(formatString, TypeUtility.GetDisplayName(t))), false, s => onComplete((System.Type)s), t); + } + + menu.ShowAsContext(); + return true; + } + + public override bool DragElement(TreeViewItem targetItem, Rect targetItemRect, int row) + { + if (TimelineWindow.instance.state.editSequence.isReadOnly) + return false; + // the drop rect contains the row rect plus additional spacing. The base drag element overlaps 1/2 the height of the next track + // which interferes with track bindings + var targetTrack = targetItem as TimelineGroupGUI; + if (row > 0 && targetTrack != null && !targetTrack.dropRect.Contains(Event.current.mousePosition)) + return false; + + return base.DragElement(targetItem, targetItemRect, row); + } + + TreeViewItem GetNextItem(TreeViewItem item) + { + if (item == null) + return null; + + if (item.parent == null) + { + int row = m_Window.treeView.data.GetRow(item.id); + var items = m_Window.treeView.data.GetRows(); + if (items.Count > row + 1) + return items[row + 1]; + return null; + } + + var children = item.parent.children; + if (children == null) + return null; + + for (int i = 0; i < children.Count - 1; i++) + { + if (children[i] == item) + return children[i + 1]; + } + return null; + } + + private static TrackAsset GetTrack(TreeViewItem item) + { + TimelineTrackBaseGUI baseGui = item as TimelineTrackBaseGUI; + if (baseGui == null) + return null; + return baseGui.track; + } + + // The drag and drop may be over an expanded group but might be between tracks + private void HandleNestedItemGUI(ref TreeViewItem parentItem, ref TreeViewItem targetItem, ref TreeViewItem insertBefore) + { + const float kTopPad = 5; + const float kBottomPad = 5; + + insertBefore = null; + + if (!ShouldUseHierarchyDragAndDrop()) + return; + + var targetTrack = targetItem as TimelineGroupGUI; + if (targetTrack == null) + return; + + var mousePosition = Event.current.mousePosition; + + var dropBefore = targetTrack.rowRect.yMin + kTopPad > mousePosition.y; + var dropAfter = !(targetTrack.track is GroupTrack) && (targetTrack.rowRect.yMax - kBottomPad < mousePosition.y); + + targetTrack.drawInsertionMarkerBefore = dropBefore; + targetTrack.drawInsertionMarkerAfter = dropAfter; + + if (dropBefore) + { + targetItem = parentItem; + parentItem = targetItem != null ? targetItem.parent : null; + insertBefore = targetTrack; + } + else if (dropAfter) + { + targetItem = parentItem; + parentItem = targetItem != null ? targetItem.parent : null; + insertBefore = GetNextItem(targetTrack); + } + else if (targetTrack.track is GroupTrack) + { + targetTrack.isDropTarget = true; + } + } + + public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, DropPosition dropPos) + { + m_Window.isDragging = false; + + var retMode = DragAndDropVisualMode.None; + + var trackDragData = DragAndDrop.GetGenericData(k_GenericDragId) as TimelineDragData; + + if (trackDragData != null) + { + retMode = HandleTrackDrop(parentItem, targetItem, perform, dropPos); + if (retMode == DragAndDropVisualMode.Copy && targetItem != null && Event.current.type == EventType.DragUpdated) + { + var targetActor = targetItem as TimelineGroupGUI; + if (targetActor != null) + targetActor.isDropTarget = true; + } + } + else if (DragAndDrop.objectReferences.Any()) + { + var objectsBeingDropped = DragAndDrop.objectReferences.OfType(); + var director = m_Window.state.editSequence.director; + + if (ShouldUseHierarchyDragAndDrop()) + { + // for object drawing + var originalTarget = targetItem; + TreeViewItem insertBeforeItem = null; + HandleNestedItemGUI(ref parentItem, ref targetItem, ref insertBeforeItem); + var track = GetTrack(targetItem); + var parent = GetTrack(parentItem); + var insertBefore = GetTrack(insertBeforeItem); + retMode = HandleHierarchyPaneDragAndDrop(objectsBeingDropped, track, perform, m_Timeline, director, ResolveType, insertBefore); + + // fallback to old clip behaviour + if (retMode == DragAndDropVisualMode.None) + { + retMode = HandleClipPaneObjectDragAndDrop(objectsBeingDropped, track, perform, m_Timeline, parent, director, m_Window.state.timeAreaShownRange.x, ResolveType, insertBefore); + } + + // if we are rejected, clear any drop markers + if (retMode == DragAndDropVisualMode.Rejected && targetItem != null) + { + ClearInsertionMarkers(originalTarget); + ClearInsertionMarkers(targetItem); + ClearInsertionMarkers(parentItem); + ClearInsertionMarkers(insertBeforeItem); + } + } + else + { + var candidateTime = TimelineHelpers.GetCandidateTime(Event.current.mousePosition); + retMode = HandleClipPaneObjectDragAndDrop(objectsBeingDropped, GetTrack(targetItem), perform, m_Timeline, GetTrack(parentItem), director, candidateTime, ResolveType); + } + } + + m_Window.isDragging = false; + + return retMode; + } + + void ClearInsertionMarkers(TreeViewItem item) + { + var trackGUI = item as TimelineTrackBaseGUI; + if (trackGUI != null) + { + trackGUI.drawInsertionMarkerAfter = false; + trackGUI.drawInsertionMarkerBefore = false; + trackGUI.isDropTarget = false; + } + } + + bool ShouldUseHierarchyDragAndDrop() + { + return m_Window.state.IsEditingAnEmptyTimeline() || m_Window.state.sequencerHeaderWidth > Event.current.mousePosition.x; + } + + public static DragAndDropVisualMode HandleHierarchyPaneDragAndDrop(IEnumerable objectsBeingDropped, TrackAsset targetTrack, bool perform, TimelineAsset timeline, PlayableDirector director, TypeResolver typeResolver, TrackAsset insertBefore = null) + { + if (timeline == null) + return DragAndDropVisualMode.Rejected; + + // if we are over a target track, defer to track binding system (implemented in TrackGUIs), unless we are a groupTrack + if (targetTrack != null && (targetTrack as GroupTrack) == null) + return DragAndDropVisualMode.None; + + if (targetTrack != null && targetTrack.lockedInHierarchy) + return DragAndDropVisualMode.Rejected; + + var tracksWithBinding = objectsBeingDropped.SelectMany(TypeUtility.GetTracksCreatableFromObject).Distinct(); + if (!tracksWithBinding.Any()) + return DragAndDropVisualMode.None; + + if (perform) + { + System.Action onResolve = trackType => + { + foreach (var obj in objectsBeingDropped) + { + if (!obj.IsPrefab() && TypeUtility.IsTrackCreatableFromObject(obj, trackType)) + { + var newTrack = TimelineHelpers.CreateTrack(timeline, trackType, targetTrack, string.Empty); + if (insertBefore != null) + { + if (targetTrack != null) + targetTrack.MoveLastTrackBefore(insertBefore); + else + timeline.MoveLastTrackBefore(insertBefore); + } + + TimelineHelpers.Bind(newTrack, obj, director); + } + } + TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved); + }; + typeResolver(tracksWithBinding, onResolve, k_SelectTrackWithBinding); + } + + return DragAndDropVisualMode.Copy; + } + + public static DragAndDropVisualMode HandleClipPaneObjectDragAndDrop(IEnumerable objectsBeingDropped, TrackAsset targetTrack, bool perform, TimelineAsset timeline, TrackAsset parent, PlayableDirector director, double candidateTime, TypeResolver typeResolver, TrackAsset insertBefore = null) + { + if (timeline == null) + return DragAndDropVisualMode.Rejected; + + // locked tracks always reject + if (targetTrack != null && targetTrack.lockedInHierarchy) + return DragAndDropVisualMode.Rejected; + + // treat group tracks as having no track + if (targetTrack is GroupTrack) + { + parent = targetTrack; + targetTrack = null; + } + + // Special case for monoscripts, since they describe the type + if (objectsBeingDropped.Any(o => o is MonoScript)) + return HandleClipPaneMonoScriptDragAndDrop(objectsBeingDropped.OfType(), targetTrack, perform, timeline, parent, director, candidateTime); + + // no unity objects, or explicit exceptions + if (!objectsBeingDropped.Any() || objectsBeingDropped.Any(o => !ValidateObjectDrop(o))) + return DragAndDropVisualMode.Rejected; + + // reject scene references if we have no context + if (director == null && objectsBeingDropped.Any(o => o.IsSceneObject())) + return DragAndDropVisualMode.Rejected; + + var validTrackTypes = objectsBeingDropped.SelectMany(o => TypeUtility.GetTrackTypesForObject(o)).Distinct().ToList(); + // special case for playable assets + if (objectsBeingDropped.Any(o => TypeUtility.IsConcretePlayableAsset(o.GetType()))) + { + var playableAssets = objectsBeingDropped.OfType().Where(o => TypeUtility.IsConcretePlayableAsset(o.GetType())); + return HandleClipPanePlayableAssetDragAndDrop(playableAssets, targetTrack, perform, timeline, parent, director, candidateTime, typeResolver); + } + + var markerTypes = objectsBeingDropped.SelectMany(o => TypeUtility.MarkerTypesWithFieldForObject(o)).Distinct(); + + // No tracks or markers support this object + if (!(markerTypes.Any() || validTrackTypes.Any())) + { + return DragAndDropVisualMode.Rejected; + } + // track is not compatible with marker + if (targetTrack != null && markerTypes.Any(o => !TypeUtility.DoesTrackSupportMarkerType(targetTrack, o))) + { + // track is not compatible with object + if (!validTrackTypes.Contains(targetTrack.GetType())) + return DragAndDropVisualMode.Rejected; + } + + // there is no target track, dropping to empty space, or onto a group + if (perform) + { + // choose track and then clip + if (targetTrack == null) + { + var createdTrack = HandleTrackAndItemCreation(objectsBeingDropped, candidateTime, typeResolver, timeline, parent, validTrackTypes, insertBefore); + if (!createdTrack) + { + timeline.CreateMarkerTrack(); + HandleItemCreation(objectsBeingDropped, timeline.markerTrack, candidateTime, typeResolver, true); // menu is always popped if ambiguous choice + } + } + // just choose clip/marker + else + { + HandleItemCreation(objectsBeingDropped, targetTrack, candidateTime, typeResolver, true); // menu is always popped if ambiguous choice + } + } + + return DragAndDropVisualMode.Copy; + } + + static bool HandleTrackAndItemCreation(IEnumerable objectsBeingDropped, double candidateTime, TypeResolver typeResolver, TimelineAsset timeline, TrackAsset parent, IEnumerable validTrackTypes, TrackAsset insertBefore = null) + { + Action onResolved = t => + { + var newTrack = TimelineHelpers.CreateTrack(timeline, t, parent, string.Empty); + if (insertBefore != null) + { + if (parent != null) + parent.MoveLastTrackBefore(insertBefore); + else + timeline.MoveLastTrackBefore(insertBefore); + } + HandleItemCreation(objectsBeingDropped, newTrack, candidateTime, typeResolver, validTrackTypes.Count() == 1); // menu is popped if ambiguous clip choice and unambiguous track choice + }; + return typeResolver(validTrackTypes, t => onResolved(t), k_SelectTrackWithClip); // Did it create a track + } + + static void HandleItemCreation(IEnumerable objectsBeingDropped, TrackAsset targetTrack, double candidateTime, TypeResolver typeResolver, bool allowMenu) + { + var assetTypes = objectsBeingDropped.Select(o => + TypeUtility.GetAssetTypesForObject(targetTrack.GetType(), o) + .Union(TypeUtility.MarkerTypesWithFieldForObject(o))).ToList(); + Action onCreateItem = assetType => + { + if (typeof(PlayableAsset).IsAssignableFrom(assetType)) + { + TimelineHelpers.CreateClipsFromObjects(assetType, targetTrack, candidateTime, + objectsBeingDropped); + } + else + { + TimelineHelpers.CreateMarkersFromObjects(assetType, targetTrack, candidateTime, objectsBeingDropped); + } + }; + + var flatAssetTypes = assetTypes.SelectMany(x => x).Distinct(); + // If there is a one to one mapping between assets and timeline types, no need to go through the type resolution, not ambiguous. + if (assetTypes.All(x => x.Count() <= 1)) + { + foreach (var type in flatAssetTypes) + { + onCreateItem(type); + } + } + else + { + if (!allowMenu) // If we already popped a menu, and are presented with an ambiguous choice, take the first entry + { + flatAssetTypes = new[] {flatAssetTypes.First()}; + } + + typeResolver(flatAssetTypes, onCreateItem, k_SelectClip); + } + } + + /// Handles drag and drop of a mono script. + public static DragAndDropVisualMode HandleClipPaneMonoScriptDragAndDrop(IEnumerable scriptsBeingDropped, TrackAsset targetTrack, bool perform, TimelineAsset timeline, TrackAsset parent, PlayableDirector director, double candidateTime) + { + var playableAssetTypes = scriptsBeingDropped.Select(s => s.GetClass()).Where(TypeUtility.IsConcretePlayableAsset).Distinct(); + if (!playableAssetTypes.Any()) + return DragAndDropVisualMode.Rejected; + + var targetTrackType = typeof(PlayableTrack); + if (targetTrack != null) + targetTrackType = targetTrack.GetType(); + + var trackAssetsTypes = TypeUtility.GetPlayableAssetsHandledByTrack(targetTrackType); + var supportedTypes = trackAssetsTypes.Intersect(playableAssetTypes); + if (!supportedTypes.Any()) + return DragAndDropVisualMode.Rejected; + + if (perform) + { + if (targetTrack == null) + targetTrack = TimelineHelpers.CreateTrack(timeline, targetTrackType, parent, string.Empty); + TimelineHelpers.CreateClipsFromTypes(supportedTypes, targetTrack, candidateTime); + } + + return DragAndDropVisualMode.Copy; + } + + public static DragAndDropVisualMode HandleClipPanePlayableAssetDragAndDrop(IEnumerable assetsBeingDropped, TrackAsset targetTrack, bool perform, TimelineAsset timeline, TrackAsset parent, PlayableDirector director, double candidateTime, TypeResolver typeResolver) + { + // get the list of supported track types + var assetTypes = assetsBeingDropped.Select(x => x.GetType()).Distinct(); + IEnumerable supportedTypes = null; + if (targetTrack == null) + { + supportedTypes = TypeUtility.AllTrackTypes().Where(t => TypeUtility.GetPlayableAssetsHandledByTrack(t).Intersect(assetTypes).Any()).ToList(); + } + else + { + supportedTypes = Enumerable.Empty(); + var trackAssetTypes = TypeUtility.GetPlayableAssetsHandledByTrack(targetTrack.GetType()); + if (trackAssetTypes.Intersect(assetTypes).Any()) + supportedTypes = new[] {targetTrack.GetType()}; + } + + if (!supportedTypes.Any()) + return DragAndDropVisualMode.Rejected; + + if (perform) + { + Action onResolved = (t) => + { + if (targetTrack == null) + targetTrack = TimelineHelpers.CreateTrack(timeline, t, parent, string.Empty); + + var clipTypes = TypeUtility.GetPlayableAssetsHandledByTrack(targetTrack.GetType()); + foreach (var asset in assetsBeingDropped) + { + if (clipTypes.Contains(asset.GetType())) + TimelineHelpers.CreateClipOnTrackFromPlayableAsset(asset, targetTrack, candidateTime); + } + }; + + typeResolver(supportedTypes, onResolved, k_SelectTrackWithClip); + } + + + return DragAndDropVisualMode.Copy; + } + + static bool ValidateObjectDrop(UnityObject obj) + { + // legacy animation clips are not supported at all + AnimationClip clip = obj as AnimationClip; + if (clip != null && clip.legacy) + return false; + + return !(obj is TimelineAsset); + } + + public DragAndDropVisualMode HandleTrackDrop(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, DropPosition dropPos) + { + ((TimelineTreeView)m_Window.treeView.gui).showInsertionMarker = false; + var trackDragData = (TimelineDragData)DragAndDrop.GetGenericData(k_GenericDragId); + bool validDrag = ValidDrag(targetItem, trackDragData.draggedItems); + if (!validDrag) + return DragAndDropVisualMode.None; + + + var draggedTracks = trackDragData.draggedItems.OfType().Select(x => x.track).ToList(); + if (draggedTracks.Count == 0) + return DragAndDropVisualMode.None; + + if (parentItem != null) + { + var parentActor = parentItem as TimelineGroupGUI; + if (parentActor != null && parentActor.track != null) + { + if (parentActor.track.lockedInHierarchy) + return DragAndDropVisualMode.Rejected; + + if (draggedTracks.Any(x => !TimelineCreateUtilities.ValidateParentTrack(parentActor.track, x.GetType()))) + return DragAndDropVisualMode.Rejected; + } + } + + var insertAfterItem = targetItem as TimelineGroupGUI; + if (insertAfterItem != null && insertAfterItem.track != null) + { + ((TimelineTreeView)m_Window.treeView.gui).showInsertionMarker = true; + } + + if (dropPos == DropPosition.Upon) + { + var groupGUI = targetItem as TimelineGroupGUI; + if (groupGUI != null) + groupGUI.isDropTarget = true; + } + + if (perform) + { + PlayableAsset targetParent = m_Timeline; + var parentActor = parentItem as TimelineGroupGUI; + + if (parentActor != null && parentActor.track != null) + targetParent = parentActor.track; + + TrackAsset siblingTrack = insertAfterItem != null ? insertAfterItem.track : null; + + // where the user drops after the last track, make sure to place it after all the tracks + if (targetParent == m_Timeline && dropPos == DropPosition.Below && siblingTrack == null) + { + siblingTrack = m_Timeline.GetRootTracks().LastOrDefault(x => !draggedTracks.Contains(x)); + } + + if (TrackExtensions.ReparentTracks(TrackExtensions.FilterTracks(draggedTracks).ToList(), targetParent, siblingTrack, dropPos == DropPosition.Above)) + { + m_Window.state.Refresh(); + } + } + + return DragAndDropVisualMode.Move; + } + + public static void HandleBindingDragAndDrop(TrackAsset dropTarget, Type requiredBindingType) + { + var objectBeingDragged = DragAndDrop.objectReferences[0]; + + var action = BindingUtility.GetBindingAction(requiredBindingType, objectBeingDragged); + DragAndDrop.visualMode = action == BindingAction.DoNotBind + ? DragAndDropVisualMode.Rejected + : DragAndDropVisualMode.Link; + + if (action == BindingAction.DoNotBind || Event.current.type != EventType.DragPerform) + return; + + var director = TimelineEditor.inspectedDirector; + + switch (action) + { + case BindingAction.BindDirectly: + { + BindingUtility.Bind(director, dropTarget, objectBeingDragged); + break; + } + case BindingAction.BindToExistingComponent: + { + var gameObjectBeingDragged = objectBeingDragged as GameObject; + Debug.Assert(gameObjectBeingDragged != null, "The object being dragged was detected as being a GameObject"); + + BindingUtility.Bind(director, dropTarget, gameObjectBeingDragged.GetComponent(requiredBindingType)); + break; + } + case BindingAction.BindToMissingComponent: + { + var gameObjectBeingDragged = objectBeingDragged as GameObject; + Debug.Assert(gameObjectBeingDragged != null, "The object being dragged was detected as being a GameObject"); + + var typeNameOfComponent = requiredBindingType.ToString().Split(".".ToCharArray()).Last(); + var bindMenu = new GenericMenu(); + + bindMenu.AddItem( + EditorGUIUtility.TextContent("Create " + typeNameOfComponent + " on " + gameObjectBeingDragged.name), + false, + nullParam => BindingUtility.Bind(director, dropTarget, Undo.AddComponent(gameObjectBeingDragged, requiredBindingType)), + null); + + bindMenu.AddSeparator(""); + bindMenu.AddItem(EditorGUIUtility.TrTextContent("Cancel"), false, userData => {}, null); + bindMenu.ShowAsContext(); + + break; + } + default: + { + //no-op + return; + } + } + + DragAndDrop.AcceptDrag(); + } + + static bool ValidDrag(TreeViewItem target, List draggedItems) + { + TreeViewItem currentParent = target; + while (currentParent != null) + { + if (draggedItems.Contains(currentParent)) + return false; + currentParent = currentParent.parent; + } + + // dragging into the sequence itself + return true; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineDragging.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineDragging.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..4aff0f87b6de641cc52763b9e49f6a21b62b3685 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineDragging.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fcd66bf74cbeb264aa99679c7df84427 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineTreeView.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineTreeView.cs new file mode 100644 index 0000000000000000000000000000000000000000..c5600f1f9ae4aefd3b3d7404e2083d18323a1879 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineTreeView.cs @@ -0,0 +1,439 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEditor.IMGUI.Controls; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class TimelineTreeView : ITreeViewGUI + { + float m_FoldoutWidth; + Rect m_DraggingInsertionMarkerRect; + readonly TreeViewController m_TreeView; + + List m_RowRects = new List(); + List m_ExpandedRowRects = new List(); + + float m_MaxWidthOfRows; + readonly WindowState m_State; + + static readonly float kMinTrackHeight = 25.0f; + static readonly float kFoldOutOffset = 14.0f; + + static DirectorStyles m_Styles; + + public bool showInsertionMarker { get; set; } + public virtual float topRowMargin { get; private set; } + public virtual float bottomRowMargin { get; private set; } + + public TimelineTreeView(TimelineWindow sequencerWindow, TreeViewController treeView) + { + m_TreeView = treeView; + m_TreeView.useExpansionAnimation = true; + + m_TreeView.selectionChangedCallback += SelectionChangedCallback; + m_TreeView.contextClickOutsideItemsCallback += ContextClickOutsideItemsCallback; + m_TreeView.itemDoubleClickedCallback += ItemDoubleClickedCallback; + m_TreeView.contextClickItemCallback += ContextClickItemCallback; + + m_TreeView.SetConsumeKeyDownEvents(false); + m_Styles = DirectorStyles.Instance; + m_State = sequencerWindow.state; + + m_FoldoutWidth = DirectorStyles.Instance.foldout.fixedWidth; + } + + void ItemDoubleClickedCallback(int id) + { + var trackGUI = m_TreeView.FindItem(id) as TimelineTrackGUI; + if (trackGUI == null) + return; + + if (trackGUI.track == null || trackGUI.track.lockedInHierarchy) + return; + + var selection = SelectionManager.SelectedItems().ToList(); + var items = ItemsUtils.GetItems(trackGUI.track).ToList(); + var addToSelection = !selection.SequenceEqual(items); + + foreach (var i in items) + { + if (addToSelection) + SelectionManager.Add(i); + else + SelectionManager.Remove(i); + } + } + + void ContextClickOutsideItemsCallback() + { + SequencerContextMenu.ShowNewTracksContextMenu(null, m_State); + Event.current.Use(); + } + + void ContextClickItemCallback(int id) + { + // may not occur if another menu is active + if (!m_TreeView.IsSelected(id)) + SelectionChangedCallback(new[] {id}); + + SequencerContextMenu.ShowTrackContextMenu(Event.current.mousePosition); + + Event.current.Use(); + } + + void SelectionChangedCallback(int[] ids) + { + if (Event.current.button == 1 && PickerUtils.TopmostPickedItem() is ISelectable) + return; + + if (Event.current.command || Event.current.control || Event.current.shift) + SelectionManager.UnSelectTracks(); + else + SelectionManager.Clear(); + + foreach (var id in ids) + { + var trackGUI = (TimelineTrackBaseGUI)m_TreeView.FindItem(id); + SelectionManager.Add(trackGUI.track); + } + + m_State.GetWindow().Repaint(); + } + + public void OnInitialize() {} + + public Rect GetRectForFraming(int row) + { + return GetRowRect(row, 1); // We ignore width by default when framing (only y scroll is affected) + } + + protected virtual Vector2 GetSizeOfRow(TreeViewItem item) + { + if (item.displayName == "root") + return new Vector2(m_TreeView.GetTotalRect().width, 0.0f); + + var trackGroupGui = item as TimelineGroupGUI; + if (trackGroupGui != null) + { + return new Vector2(m_TreeView.GetTotalRect().width, trackGroupGui.GetHeight(m_State)); + } + + float height = TrackEditor.DefaultTrackHeight; + if (item.hasChildren && m_TreeView.data.IsExpanded(item)) + { + height = Mathf.Min(TrackEditor.DefaultTrackHeight, kMinTrackHeight); + } + + return new Vector2(m_TreeView.GetTotalRect().width, height); + } + + public virtual void BeginRowGUI() + { + if (m_TreeView.GetTotalRect().width != GetRowRect(0).width) + { + CalculateRowRects(); + } + + m_DraggingInsertionMarkerRect.x = -1; + + m_TreeView.SetSelection(SelectionManager.SelectedTrackGUI().Select(t => t.id).ToArray(), false); + } + + public virtual void EndRowGUI() + { + // Draw row marker when dragging + if (m_DraggingInsertionMarkerRect.x >= 0 && Event.current.type == EventType.Repaint) + { + Rect insertionRect = m_DraggingInsertionMarkerRect; + const float insertionHeight = 1.0f; + insertionRect.height = insertionHeight; + + if (m_TreeView.dragging.drawRowMarkerAbove) + insertionRect.y -= insertionHeight * 0.5f + 2.0f; + else + insertionRect.y += m_DraggingInsertionMarkerRect.height - insertionHeight * 0.5f + 1.0f; + + EditorGUI.DrawRect(insertionRect, Color.white); + } + } + + public virtual void OnRowGUI(Rect rowRect, TreeViewItem item, int row, bool selected, bool focused) + { + using (new EditorGUI.DisabledScope(TimelineWindow.instance.currentMode.TrackState(TimelineWindow.instance.state) == TimelineModeGUIState.Disabled)) + { + var sqvi = (TimelineTrackBaseGUI)item; + sqvi.treeViewToWindowTransformation = m_TreeView.GetTotalRect().position - m_TreeView.state.scrollPos; + + // this may be called because an encompassing parent is visible + if (!sqvi.visibleExpanded) + return; + + Rect headerRect = rowRect; + Rect contentRect = rowRect; + + headerRect.width = m_State.sequencerHeaderWidth - 2.0f; + contentRect.xMin += m_State.sequencerHeaderWidth; + contentRect.width = rowRect.width - m_State.sequencerHeaderWidth - 1.0f; + + Rect foldoutRect = rowRect; + + var indent = GetFoldoutIndent(item); + var headerRectWithIndent = headerRect; + headerRectWithIndent.xMin = indent; + var rowRectWithIndent = new Rect(rowRect.x + indent, rowRect.y, rowRect.width - indent, rowRect.height); + sqvi.Draw(headerRectWithIndent, contentRect, m_State); + sqvi.DrawInsertionMarkers(rowRectWithIndent); + + if (Event.current.type == EventType.Repaint) + { + m_State.spacePartitioner.AddBounds(sqvi); + + // Show marker below this Item + if (showInsertionMarker) + { + if (m_TreeView.dragging != null && m_TreeView.dragging.GetRowMarkerControlID() == TreeViewController.GetItemControlID(item)) + m_DraggingInsertionMarkerRect = rowRectWithIndent; + } + } + + // Draw foldout (after text content above to ensure drop down icon is rendered above selection highlight) + DrawFoldout(item, foldoutRect, indent); + + sqvi.ClearDrawFlags(); + } + } + + void DrawFoldout(TreeViewItem item, Rect foldoutRect, float indent) + { + var showFoldout = m_TreeView.data.IsExpandable(item); + if (showFoldout) + { + foldoutRect.x = indent - kFoldOutOffset; + foldoutRect.width = m_FoldoutWidth; + EditorGUI.BeginChangeCheck(); + float foldoutIconHeight = DirectorStyles.Instance.foldout.fixedHeight; + foldoutRect.y += foldoutIconHeight / 2.0f; + foldoutRect.height = foldoutIconHeight; + + if (foldoutRect.xMax > m_State.sequencerHeaderWidth) + return; + + //Override Disable state for TrakGroup toggle button to expand/collapse group. + bool previousEnableState = GUI.enabled; + GUI.enabled = true; + bool newExpandedValue = GUI.Toggle(foldoutRect, m_TreeView.data.IsExpanded(item), GUIContent.none, m_Styles.foldout); + GUI.enabled = previousEnableState; + + if (EditorGUI.EndChangeCheck()) + { + if (Event.current.alt) + m_TreeView.data.SetExpandedWithChildren(item, newExpandedValue); + else + m_TreeView.data.SetExpanded(item, newExpandedValue); + } + } + } + + public Rect GetRenameRect(Rect rowRect, int row, TreeViewItem item) + { + return rowRect; + } + + public void BeginPingItem(TreeViewItem item, float topPixelOfRow, float availableWidth) {} + public void EndPingItem() {} + + public Rect GetRowRect(int row, float rowWidth) + { + return GetRowRect(row); + } + + public Rect GetRowRect(int row) + { + if (m_RowRects.Count == 0) + return new Rect(); + + if (row >= m_RowRects.Count) + return new Rect(); + + return m_RowRects[row]; + } + + static float GetSpacing(TreeViewItem item) + { + var trackBase = item as TimelineTrackBaseGUI; + if (trackBase != null) + return trackBase.GetVerticalSpacingBetweenTracks(); + + return 3.0f; + } + + public void CalculateRowRects() + { + if (m_TreeView.isSearching) + return; + + const float startY = 6.0f; + IList rows = m_TreeView.data.GetRows(); + m_RowRects = new List(rows.Count); + m_ExpandedRowRects = new List(rows.Count); + + float curY = startY; + m_MaxWidthOfRows = 1f; + + // first pass compute the row rects + for (int i = 0; i < rows.Count; ++i) + { + var item = rows[i]; + + if (i != 0) + curY += GetSpacing(item); + + Vector2 rowSize = GetSizeOfRow(item); + m_RowRects.Add(new Rect(0, curY, rowSize.x, rowSize.y)); + m_ExpandedRowRects.Add(m_RowRects[i]); + + curY += rowSize.y; + + if (rowSize.x > m_MaxWidthOfRows) + m_MaxWidthOfRows = rowSize.x; + + // updated the expanded state + var groupGUI = item as TimelineGroupGUI; + if (groupGUI != null) + groupGUI.SetExpanded(m_TreeView.data.IsExpanded(item)); + } + + float halfHeight = halfDropBetweenHeight; + const float kGroupPad = 1.0f; + const float kSkinPadding = 5.0f * 0.6f; + // work bottom up and compute visible regions for groups + for (int i = rows.Count - 1; i > 0; i--) + { + float height = 0; + TimelineTrackBaseGUI item = (TimelineTrackBaseGUI)rows[i]; + if (item.isExpanded && item.children != null && item.children.Count > 0) + { + for (var j = 0; j < item.children.Count; j++) + { + var child = item.children[j]; + int index = rows.IndexOf(child); + if (index > i) + height += m_ExpandedRowRects[index].height + kSkinPadding; + } + + height += kGroupPad; + } + m_ExpandedRowRects[i] = new Rect(m_RowRects[i].x, m_RowRects[i].y, m_RowRects[i].width, m_RowRects[i].height + height); + + var groupGUI = item as TimelineGroupGUI; + if (groupGUI != null) + { + var spacing = GetSpacing(item) + 1; + groupGUI.expandedRect = m_ExpandedRowRects[i]; + groupGUI.rowRect = m_RowRects[i]; + groupGUI.dropRect = new Rect(m_RowRects[i].x, m_RowRects[i].y - spacing, m_RowRects[i].width, m_RowRects[i].height + Mathf.Max(halfHeight, spacing)); + } + } + } + + public virtual bool BeginRename(TreeViewItem item, float delay) + { + return false; + } + + public virtual void EndRename() {} + + protected virtual float GetFoldoutIndent(TreeViewItem item) + { + // Ignore depth when showing search results + if (item.depth <= 1 || m_TreeView.isSearching) + return DirectorStyles.kBaseIndent; + + int depth = item.depth; + var trackGUI = item as TimelineTrackGUI; + + // first level subtracks are not indented + if (trackGUI != null && trackGUI.track != null && trackGUI.track.isSubTrack) + depth--; + + return depth * DirectorStyles.kBaseIndent; + } + + public virtual float GetContentIndent(TreeViewItem item) + { + return GetFoldoutIndent(item); + } + + public int GetNumRowsOnPageUpDown(TreeViewItem fromItem, bool pageUp, float heightOfTreeView) + { + return (int)Mathf.Floor(heightOfTreeView / 30); // return something + } + + // Should return the row number of the first and last row thats fits in the pixel rect defined by top and height + public void GetFirstAndLastRowVisible(out int firstRowVisible, out int lastRowVisible) + { + int rowCount = m_TreeView.data.rowCount; + if (rowCount == 0) + { + firstRowVisible = lastRowVisible = -1; + return; + } + + if (rowCount != m_ExpandedRowRects.Count) + { + Debug.LogError("Mismatch in state: rows vs cached rects. Did you remember to hook up: dataSource.onVisibleRowsChanged += gui.CalculateRowRects ?"); + CalculateRowRects(); + } + + float topPixel = m_TreeView.state.scrollPos.y; + float heightInPixels = m_TreeView.GetTotalRect().height; + + int firstVisible = -1; + int lastVisible = -1; + + Rect visibleRect = new Rect(0, topPixel, m_ExpandedRowRects[0].width, heightInPixels); + for (int i = 0; i < m_ExpandedRowRects.Count; ++i) + { + bool visible = visibleRect.Overlaps(m_ExpandedRowRects[i]); + if (visible) + { + if (firstVisible == -1) + firstVisible = i; + lastVisible = i; + } + + TimelineTrackBaseGUI gui = m_TreeView.data.GetItem(i) as TimelineTrackBaseGUI; + if (gui != null) + { + gui.visibleExpanded = visible; + gui.visibleRow = visibleRect.Overlaps(m_RowRects[i]); + } + } + + if (firstVisible != -1 && lastVisible != -1) + { + firstRowVisible = firstVisible; + lastRowVisible = lastVisible; + } + else + { + firstRowVisible = 0; + lastRowVisible = rowCount - 1; + } + } + + public Vector2 GetTotalSize() + { + if (m_RowRects.Count == 0) + return new Vector2(0, 0); + + return new Vector2(m_MaxWidthOfRows, m_RowRects[m_RowRects.Count - 1].yMax); + } + + public virtual float halfDropBetweenHeight + { + get { return 8f; } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineTreeView.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineTreeView.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a555d92d1a6cc06eccc065040693fbd615cd8211 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineTreeView.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 82a8ce43816925d4b971951094cb755c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineTreeViewGUI.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineTreeViewGUI.cs new file mode 100644 index 0000000000000000000000000000000000000000..26e30119fc82229e8c4b425a80e1476f22a6b556 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineTreeViewGUI.cs @@ -0,0 +1,180 @@ +using System.Collections.Generic; +using System.Linq; +using UnityEditor.IMGUI.Controls; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TimelineTreeViewGUI + { + readonly TimelineAsset m_Timeline; + readonly TreeViewController m_TreeView; + readonly TimelineTreeView m_TimelineTreeView; + readonly TimelineWindow m_Window; + readonly TimelineDataSource m_DataSource; + + TreeViewItem root + { + get { return m_DataSource.root; } + } + + TimelineTrackBaseGUI[] visibleTrackGuis + { + get + { + int firstRow; + int lastRow; + var visibleRows = new List(); + m_TreeView.gui.GetFirstAndLastRowVisible(out firstRow, out lastRow); + + for (int r = firstRow; r <= lastRow; r++) + { + var track = m_TreeView.data.GetItem(r) as TimelineTrackBaseGUI; + if (track != null && track != root) + { + AddVisibleTrackRecursive(ref visibleRows, track); + } + } + return visibleRows.ToArray(); + } + } + + public TrackAsset[] visibleTracks + { + get { return visibleTrackGuis.Select(x => x.track).ToArray(); } + } + + public List allClipGuis + { + get + { + TimelineDataSource dataSource = m_TreeView.data as TimelineDataSource; + if (dataSource != null && dataSource.allTrackGuis != null) + return dataSource.allTrackGuis.OfType().SelectMany(x => x.clips).ToList(); + + return null; + } + } + + public List allTrackGuis + { + get + { + var dataSource = m_TreeView.data as TimelineDataSource; + if (dataSource != null) + return dataSource.allTrackGuis; + return null; + } + } + + public Vector2 contentSize + { + get { return m_TreeView.GetContentSize(); } + } + + public Vector2 scrollPosition + { + get { return m_TreeView.state.scrollPos; } + set + { + Rect r = m_TreeView.GetTotalRect(); + Vector2 visibleContent = m_TreeView.GetContentSize(); + m_TreeView.state.scrollPos = new Vector2(value.x, Mathf.Clamp(value.y, 0, Mathf.Max(0, visibleContent.y - r.height))); + } + } + + public bool showingVerticalScrollBar + { + get { return m_TreeView.showingVerticalScrollBar; } + } + + public void FrameItem(TreeViewItem item) + { + m_TreeView.Frame(item.id, true, false, true); + } + + public TimelineDragging timelineDragging { get {return m_TreeView.dragging as TimelineDragging; }} + + public TimelineTreeViewGUI(TimelineWindow sequencerWindow, TimelineAsset timeline, Rect rect) + { + m_Timeline = timeline; + m_Window = sequencerWindow; + + var treeviewState = new TreeViewState(); + treeviewState.scrollPos = new Vector2(treeviewState.scrollPos.x, TimelineWindowViewPrefs.GetOrCreateViewModel(m_Timeline).verticalScroll); + + m_TreeView = new TreeViewController(sequencerWindow, treeviewState); + m_TreeView.horizontalScrollbarStyle = GUIStyle.none; + m_TreeView.scrollViewStyle = GUI.skin.scrollView; + + m_TimelineTreeView = new TimelineTreeView(sequencerWindow, m_TreeView); + var dragging = new TimelineDragging(m_TreeView, m_Window, m_Timeline); + m_DataSource = new TimelineDataSource(this, m_TreeView, sequencerWindow); + + m_DataSource.onVisibleRowsChanged += m_TimelineTreeView.CalculateRowRects; + m_TreeView.Init(rect, m_DataSource, m_TimelineTreeView, dragging); + + m_DataSource.ExpandItems(m_DataSource.root); + } + + public ITreeViewGUI gui + { + get { return m_TimelineTreeView; } + } + public ITreeViewDataSource data + { + get { return m_TreeView == null ? null : m_TreeView.data; } + } + + public TimelineWindow TimelineWindow + { + get { return m_Window; } + } + + public void CalculateRowRects() + { + m_TimelineTreeView.CalculateRowRects(); + } + + public void Reload() + { + AnimationClipCurveCache.Instance.ClearCachedProxyClips(); + + m_TreeView.ReloadData(); + m_DataSource.ExpandItems(m_DataSource.root); + m_TimelineTreeView.CalculateRowRects(); + } + + public void OnGUI(Rect rect) + { + int keyboardControl = GUIUtility.GetControlID(FocusType.Passive, rect); + m_TreeView.OnGUI(rect, keyboardControl); + TimelineWindowViewPrefs.GetOrCreateViewModel(m_Timeline).verticalScroll = m_TreeView.state.scrollPos.y; + } + + public Rect GetRowRect(int row) + { + return m_TimelineTreeView.GetRowRect(row); + } + + static void AddVisibleTrackRecursive(ref List list, TimelineTrackBaseGUI track) + { + if (track == null) + return; + + list.Add(track); + + if (!track.isExpanded) + return; + + if (track.children != null) + { + foreach (var c in track.children) + { + AddVisibleTrackRecursive(ref list, c as TimelineTrackBaseGUI); + } + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineTreeViewGUI.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineTreeViewGUI.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..7363134a8b0b80f3595e6308ead89fbed552dee5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TimelineTreeViewGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f9d8c8b21846a654092a24f25aa41421 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui.meta new file mode 100644 index 0000000000000000000000000000000000000000..bd594b5cd13ad6338fcc512dad2dcedc59322c17 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 3d453576028bb344db0d59db893bf3a6 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/InlineCurveEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/InlineCurveEditor.cs new file mode 100644 index 0000000000000000000000000000000000000000..06dd72764fa07f8dbd006f93407548a2a7df421f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/InlineCurveEditor.cs @@ -0,0 +1,310 @@ +using System.Linq; +using JetBrains.Annotations; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + interface IClipCurveEditorOwner + { + ClipCurveEditor clipCurveEditor { get; } + bool inlineCurvesSelected { get; } + bool showLoops { get; } + TrackAsset owner { get; } + void SelectCurves(); + void ValidateCurvesSelection(); + } + + class InlineCurveResizeHandle : IBounds + { + public Rect boundingRect { get; private set; } + + public TimelineTrackGUI trackGUI { get; } + + public InlineCurveResizeHandle(TimelineTrackGUI trackGUI) + { + this.trackGUI = trackGUI; + } + + public void Draw(Rect headerRect, WindowState state) + { + const float resizeHandleHeight = WindowConstants.trackResizeHandleHeight; + var rect = new Rect(headerRect.xMin, headerRect.yMax - resizeHandleHeight + 1f, headerRect.width, resizeHandleHeight); + EditorGUIUtility.AddCursorRect(rect, MouseCursor.SplitResizeUpDown); + + boundingRect = trackGUI.ToWindowSpace(rect); + + if (Event.current.type == EventType.Repaint) + { + state.headerSpacePartitioner.AddBounds(this); + EditorGUI.DrawRect(rect, DirectorStyles.Instance.customSkin.colorAnimEditorBinding); + var dragStyle = DirectorStyles.Instance.inlineCurveHandle; + dragStyle.Draw(rect, GUIContent.none, false, false, false, false); + } + } + } + + class InlineCurveEditor : IBounds + { + Rect m_TrackRect; + Rect m_HeaderRect; + readonly TimelineTrackGUI m_TrackGUI; + readonly InlineCurveResizeHandle m_ResizeHandle; + + bool m_LastSelectionWasClip; + TimelineClipGUI m_LastSelectedClipGUI; + + Rect IBounds.boundingRect { get { return m_TrackGUI.ToWindowSpace(m_TrackRect); } } + + [UsedImplicitly] // Used in tests + public TimelineClipGUI currentClipGui + { + get { return m_LastSelectedClipGUI; } + } + + public IClipCurveEditorOwner currentCurveEditor + { + get { return m_LastSelectionWasClip ? (IClipCurveEditorOwner)m_LastSelectedClipGUI : (IClipCurveEditorOwner)m_TrackGUI; } + } + + public InlineCurveEditor(TimelineTrackGUI trackGUI) + { + m_TrackGUI = trackGUI; + m_ResizeHandle = new InlineCurveResizeHandle(trackGUI); + } + + static bool MouseOverTrackArea(Rect curveRect, Rect trackRect) + { + curveRect.y = trackRect.y; + curveRect.height = trackRect.height; + + // clamp the curve editor to the track. this allows the menu to scroll properly + curveRect.xMin = Mathf.Max(curveRect.xMin, trackRect.xMin); + curveRect.xMax = trackRect.xMax; + + return curveRect.Contains(Event.current.mousePosition); + } + + static bool MouseOverHeaderArea(Rect headerRect, Rect trackRect) + { + headerRect.y = trackRect.y; + headerRect.height = trackRect.height; + + return headerRect.Contains(Event.current.mousePosition); + } + + static void DrawCurveEditor(IClipCurveEditorOwner clipCurveEditorOwner, WindowState state, Rect headerRect, Rect trackRect, Vector2 activeRange, bool locked) + { + ClipCurveEditor clipCurveEditor = clipCurveEditorOwner.clipCurveEditor; + CurveDataSource dataSource = clipCurveEditor.dataSource; + Rect curveRect = dataSource.GetBackgroundRect(state); + + var newlySelected = false; + var currentEvent = Event.current; + + if (currentEvent.type == EventType.MouseDown || currentEvent.type == EventType.ContextClick) + newlySelected = MouseOverTrackArea(curveRect, trackRect) || MouseOverHeaderArea(headerRect, trackRect); + + // make sure to not use any event before drawing the curve. + bool prevEnabledState = GUI.enabled; + GUI.enabled = true; + clipCurveEditorOwner.clipCurveEditor.DrawHeader(headerRect); + GUI.enabled = prevEnabledState; + + bool displayAsSelected = !locked && (clipCurveEditorOwner.inlineCurvesSelected || newlySelected); + + using (new EditorGUI.DisabledScope(locked)) + clipCurveEditor.DrawCurveEditor(trackRect, state, activeRange, clipCurveEditorOwner.showLoops, displayAsSelected); + + if (newlySelected && !locked) + OnMouseClick(clipCurveEditorOwner, currentEvent); + } + + static void OnMouseClick(IClipCurveEditorOwner clipCurveEditorOwner, Event currentEvent) + { + if (currentEvent.modifiers == ManipulatorsUtils.actionModifier) + { + if (clipCurveEditorOwner.inlineCurvesSelected) + SelectionManager.Clear(); + else + clipCurveEditorOwner.SelectCurves(); + } + else + { + clipCurveEditorOwner.SelectCurves(); + } + + HandleCurrentEvent(); + } + + public void Draw(Rect headerRect, Rect trackRect, WindowState state) + { + const float inlineCurveBottomPadding = WindowConstants.inlineCurveContentPadding; + m_TrackRect = trackRect; + m_TrackRect.height -= inlineCurveBottomPadding; + + if (Event.current.type == EventType.Repaint) + state.spacePartitioner.AddBounds(this); + + // Remove the indentation of this track to render it properly, otherwise every GUI elements will be offsetted. + headerRect.x -= DirectorStyles.kBaseIndent; + headerRect.width += DirectorStyles.kBaseIndent; + + // Remove the width of the color swatch. + headerRect.x += 4.0f; + headerRect.width -= 4.0f; + m_HeaderRect = headerRect; + EditorGUI.DrawRect(m_HeaderRect, DirectorStyles.Instance.customSkin.colorAnimEditorBinding); + + if (ShouldShowClipCurves(state)) + { + DrawCurveEditorsForClipsOnTrack(m_HeaderRect, m_TrackRect, state); + } + else if (ShouldShowTrackCurves()) + { + DrawCurveEditorForTrack(m_HeaderRect, m_TrackRect, state); + } + else + { + DrawCurvesEditorForNothingSelected(m_HeaderRect, m_TrackRect, state); + } + + m_ResizeHandle.Draw(headerRect, state); + + var bottomPadding = new Rect(trackRect.xMin, trackRect.yMax - inlineCurveBottomPadding, trackRect.width, inlineCurveBottomPadding); + EditorGUI.DrawRect(bottomPadding, DirectorStyles.Instance.customSkin.colorTrackBackground); + + // If MouseDown or ContextClick are not consumed by the curves, use the event to prevent it from going deeper into the treeview. + if (Event.current.type == EventType.ContextClick) + { + var r = Rect.MinMaxRect(m_HeaderRect.xMin, m_HeaderRect.yMin, m_TrackRect.xMax, m_TrackRect.yMax); + if (r.Contains(Event.current.mousePosition)) + Event.current.Use(); + } + + UpdateViewModel(); + } + + void DrawCurveEditorForTrack(Rect headerRect, Rect trackRect, WindowState state) + { + if (m_TrackGUI.clipCurveEditor == null) + return; + + var activeRange = new Vector2(state.TimeToPixel(0.0d), state.TimeToPixel(state.editSequence.duration)); + DrawCurveEditor(m_TrackGUI, state, headerRect, trackRect, activeRange, m_TrackGUI.locked); + m_LastSelectionWasClip = false; + } + + void DrawCurveEditorsForClipsOnTrack(Rect headerRect, Rect trackRect, WindowState state) + { + if (m_TrackGUI.clips.Count == 0) + return; + + if (Event.current.type == EventType.Layout) + { + var selectedClip = SelectionManager.SelectedClipGUI().FirstOrDefault(x => x.parent == m_TrackGUI); + if (selectedClip != null) + { + m_LastSelectedClipGUI = selectedClip; + SelectFromCurveOwner(m_LastSelectedClipGUI); + } + else if (state.recording && state.IsArmedForRecord(m_TrackGUI.track)) + { + if (m_LastSelectedClipGUI == null || !m_TrackGUI.track.IsRecordingToClip(m_LastSelectedClipGUI.clip)) + { + var clip = m_TrackGUI.clips.FirstOrDefault(x => m_TrackGUI.track.IsRecordingToClip(x.clip)); + if (clip != null) + m_LastSelectedClipGUI = clip; + } + } + + if (m_LastSelectedClipGUI == null) + m_LastSelectedClipGUI = m_TrackGUI.clips[0]; + } + + if (m_LastSelectedClipGUI == null || m_LastSelectedClipGUI.clipCurveEditor == null || m_LastSelectedClipGUI.isInvalid) + return; + + var activeRange = new Vector2(state.TimeToPixel(m_LastSelectedClipGUI.clip.start), state.TimeToPixel(m_LastSelectedClipGUI.clip.end)); + DrawCurveEditor(m_LastSelectedClipGUI, state, headerRect, trackRect, activeRange, m_TrackGUI.locked); + m_LastSelectionWasClip = true; + } + + void DrawCurvesEditorForNothingSelected(Rect headerRect, Rect trackRect, WindowState state) + { + if (m_LastSelectionWasClip || !TrackHasCurvesToShow() && m_TrackGUI.clips.Count > 0) + { + DrawCurveEditorsForClipsOnTrack(headerRect, trackRect, state); + } + else + { + DrawCurveEditorForTrack(headerRect, trackRect, state); + } + } + + bool ShouldShowClipCurves(WindowState state) + { + if (m_TrackGUI.clips.Count == 0) + return false; + + // Is a clip selected or being recorded to? + return SelectionManager.SelectedClipGUI().FirstOrDefault(x => x.parent == m_TrackGUI) != null || + state.recording && state.IsArmedForRecord(m_TrackGUI.track) && m_TrackGUI.clips.FirstOrDefault(x => m_TrackGUI.track.IsRecordingToClip(x.clip)) != null; + } + + bool ShouldShowTrackCurves() + { + if (m_TrackGUI == null) + return false; + + var isTrackSelected = SelectionManager.SelectedTrackGUI().FirstOrDefault(x => x == m_TrackGUI) != null; + + if (!isTrackSelected) + return false; + + return TrackHasCurvesToShow(); + } + + bool TrackHasCurvesToShow() + { + var animTrack = m_TrackGUI.track as AnimationTrack; + if (animTrack != null && !animTrack.inClipMode) + return true; + + return m_TrackGUI.track.HasAnyAnimatableParameters(); + } + + void UpdateViewModel() + { + var curveEditor = currentCurveEditor.clipCurveEditor; + if (curveEditor == null || curveEditor.bindingHierarchy.treeViewController == null) + return; + + var vm = TimelineWindowViewPrefs.GetTrackViewModelData(m_TrackGUI.track); + vm.inlineCurvesState = curveEditor.bindingHierarchy.treeViewController.state; + vm.inlineCurvesShownAreaInsideMargins = curveEditor.shownAreaInsideMargins; + vm.lastInlineCurveDataID = curveEditor.dataSource.id; + } + + static void HandleCurrentEvent() + { +#if UNITY_EDITOR_OSX + Event.current.type = EventType.Ignore; +#else + Event.current.Use(); +#endif + } + + static void SelectFromCurveOwner(IClipCurveEditorOwner curveOwner) + { + if (curveOwner.clipCurveEditor == null) + { + SelectionManager.SelectInlineCurveEditor(null); + } + else if (!curveOwner.inlineCurvesSelected && SelectionManager.Count() == 1) + { + SelectionManager.SelectInlineCurveEditor(curveOwner); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/InlineCurveEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/InlineCurveEditor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e476de53c8b63fe3abf4bc191b9059f08c446abd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/InlineCurveEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1e96b886242ab404db69df796f7cd9b0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineGroupGUI.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineGroupGUI.cs new file mode 100644 index 0000000000000000000000000000000000000000..e386157cd72a81c39c44c9f2ab8fdbb1075a6a49 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineGroupGUI.cs @@ -0,0 +1,323 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.IMGUI.Controls; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TimelineGroupGUI : TimelineTrackBaseGUI + { + protected DirectorStyles m_Styles; + protected Rect m_TreeViewRect = new Rect(0, 0, 0, 0); + protected GUIContent m_ProblemIcon = new GUIContent(); + + bool m_MustRecomputeUnions = true; + int m_GroupDepth; + readonly bool m_IsReferencedTrack; + readonly List m_Unions = new List(); + + public override Rect boundingRect + { + get { return ToWindowSpace(m_TreeViewRect); } + } + + public Rect ToWindowSpace(Rect localRect) + { + localRect.position += treeViewToWindowTransformation; + return localRect; + } + + public override bool expandable + { + get { return !m_IsRoot; } + } + + // The expanded rectangle (contains children) as calculated by the the tree gui + public Rect expandedRect { get; set; } + // The row rectangle (header only) as calculated by the tree gui + public Rect rowRect { get; set; } + // the drop rectangle as set by the tree gui when targetted by a drag and drop + public Rect dropRect { get; set; } + + public TimelineGroupGUI(TreeViewController treeview, TimelineTreeViewGUI treeviewGUI, int id, int depth, TreeViewItem parent, string displayName, TrackAsset trackAsset, bool isRoot) + : base(id, depth, parent, displayName, trackAsset, treeview, treeviewGUI) + { + m_Styles = DirectorStyles.Instance; + m_IsRoot = isRoot; + + var trackPath = AssetDatabase.GetAssetPath(trackAsset); + var sequencePath = AssetDatabase.GetAssetPath(treeviewGUI.TimelineWindow.state.editSequence.asset); + if (trackPath != sequencePath) + m_IsReferencedTrack = true; + + m_GroupDepth = CalculateGroupDepth(parent); + } + + public virtual float GetHeight(WindowState state) + { + // group tracks don't scale in height + return TrackEditor.DefaultTrackHeight; + } + + public override void OnGraphRebuilt() {} + + static int CalculateGroupDepth(TreeViewItem parent) + { + int depth = 0; + + bool done = false; + do + { + var gui = parent as TimelineGroupGUI; + if (gui == null || gui.track == null) + done = true; + else + { + if (gui.track is GroupTrack) + depth++; + + parent = parent.parent; + } + } + while (!done); + + return depth; + } + + void DrawTrackButtons(Rect headerRect, WindowState state) + { + const float buttonSize = WindowConstants.trackHeaderButtonSize; + const float padding = WindowConstants.trackHeaderButtonPadding; + + var buttonRect = new Rect(headerRect.xMax - buttonSize - padding, headerRect.y + ((headerRect.height - buttonSize) / 2f), buttonSize, buttonSize); + + if (GUI.Button(buttonRect, EditorGUIUtility.IconContent("CreateAddNew"), m_Styles.trackGroupAddButton)) + { + // the drop down will apply to all selected tracks + if (!SelectionManager.Contains(track)) + { + SelectionManager.Clear(); + SelectionManager.Add(track); + } + SequencerContextMenu.ShowNewTracksContextMenu(SelectionManager.SelectedTracks().ToArray(), TimelineWindow.state, buttonRect); + } + buttonRect.x -= buttonSize; + + var suitePadding = DrawButtonSuite(2, ref buttonRect); + + DrawMuteButton(buttonRect, state); + buttonRect.x -= buttonSize + padding; + DrawLockButton(buttonRect, state); + buttonRect.x -= suitePadding; + } + + public void SetExpanded(bool expanded) + { + var collapseChanged = expanded != isExpanded; + isExpanded = expanded; + if (collapseChanged) + { + track.SetCollapsed(!expanded); + m_MustRecomputeUnions = true; + } + } + + public override void Draw(Rect headerRect, Rect contentRect, WindowState state) + { + if (track == null || m_IsRoot) + return; + + if (m_MustRecomputeUnions) + RecomputeRectUnions(); + + if (depth == 1) + Graphics.DrawBackgroundRect(state, headerRect); + + var background = headerRect; + background.height = expandedRect.height; + + var groupColor = TrackResourceCache.GetTrackColor(track); + + m_TreeViewRect = contentRect; + + var col = groupColor; + + var isSelected = SelectionManager.Contains(track); + + if (isSelected) + col = DirectorStyles.Instance.customSkin.colorSelection; + else if (isDropTarget) + col = DirectorStyles.Instance.customSkin.colorDropTarget; + else + { + if (m_GroupDepth % 2 == 1) + { + float h, s, v; + Color.RGBToHSV(col, out h, out s, out v); + v += 0.06f; + col = Color.HSVToRGB(h, s, v); + } + } + + if (background.width > 0) + { + using (new GUIColorOverride(col)) + GUI.Box(background, GUIContent.none, m_Styles.groupBackground); + } + + var trackRectBackground = headerRect; + trackRectBackground.xMin += background.width; + trackRectBackground.width = contentRect.width; + trackRectBackground.height = background.height; + + if (isSelected) + { + col = state.IsEditingASubTimeline() + ? m_Styles.customSkin.colorTrackSubSequenceBackgroundSelected + : m_Styles.customSkin.colorTrackBackgroundSelected; + } + else + { + col = m_Styles.customSkin.colorGroupTrackBackground; + } + + EditorGUI.DrawRect(trackRectBackground, col); + if (!isExpanded && children != null && children.Count > 0) + { + var collapsedTrackRect = contentRect; + + foreach (var u in m_Unions) + u.Draw(collapsedTrackRect, state); + } + + using (new GUIGroupScope(headerRect)) + { + var groupRect = new Rect(0, 0, headerRect.width, headerRect.height); + DrawName(groupRect, isSelected); + DrawTrackButtons(groupRect, state); + } + + if (IsTrackRecording(state)) + { + using (new GUIColorOverride(DirectorStyles.Instance.customSkin.colorTrackBackgroundRecording)) + GUI.Label(background, GUIContent.none, m_Styles.displayBackground); + } + + // is this a referenced track? + if (m_IsReferencedTrack) + { + var refRect = contentRect; + refRect.x = state.timeAreaRect.xMax - 20.0f; + refRect.y += 5.0f; + refRect.width = 30.0f; + GUI.Label(refRect, DirectorStyles.referenceTrackLabel, EditorStyles.label); + } + + var bgRect = contentRect; + if (track as GroupTrack != null || AllChildrenMuted(this)) + bgRect.height = expandedRect.height; + DrawTrackState(contentRect, bgRect, track); + } + + void DrawName(Rect rect, bool isSelected) + { + var labelRect = rect; + labelRect.xMin += 20; + var actorName = track != null ? track.name : "missing"; + labelRect.width = m_Styles.groupFont.CalcSize(new GUIContent(actorName)).x; + labelRect.width = Math.Max(labelRect.width, 50.0f); + + // if we aren't bound to anything, we show a text field that allows to rename the actor + // otherwise we show a ObjectField to allow binding to a go + if (track != null && track is GroupTrack) + { + var textColor = m_Styles.groupFont.normal.textColor; + + if (isSelected) + textColor = Color.white; + + string newName; + + EditorGUI.BeginChangeCheck(); + using (new StyleNormalColorOverride(m_Styles.groupFont, textColor)) + { + newName = EditorGUI.DelayedTextField(labelRect, GUIContent.none, track.GetInstanceID(), track.name, m_Styles.groupFont); + } + + if (EditorGUI.EndChangeCheck() && !string.IsNullOrEmpty(newName)) + { + track.name = newName; + displayName = track.name; + } + } + } + + protected bool IsSubTrack() + { + if (track == null) + return false; + + var parentTrack = track.parent as TrackAsset; + if (parentTrack == null) + return false; + + return parentTrack.GetType() != typeof(GroupTrack); + } + + protected TrackAsset ParentTrack() + { + if (IsSubTrack()) + return track.parent as TrackAsset; + return null; + } + + // is there currently a recording track + bool IsTrackRecording(WindowState state) + { + if (!state.recording) + return false; + if (track.GetType() != typeof(GroupTrack)) + return false; + + return state.GetArmedTrack(track) != null; + } + + void RecomputeRectUnions() + { + m_MustRecomputeUnions = false; + m_Unions.Clear(); + if (children == null) + return; + + foreach (var c in children.OfType()) + { + c.RebuildGUICacheIfNecessary(); + m_Unions.AddRange(TimelineClipUnion.Build(c.clips)); + } + } + + static bool AllChildrenMuted(TimelineGroupGUI groupGui) + { + if (!groupGui.track.muted) + return false; + if (groupGui.children == null) + return true; + return groupGui.children.OfType().All(AllChildrenMuted); + } + + protected static float DrawButtonSuite(int numberOfButtons, ref Rect buttonRect) + { + var style = DirectorStyles.Instance.trackButtonSuite; + var buttonWidth = WindowConstants.trackHeaderButtonSize * numberOfButtons + WindowConstants.trackHeaderButtonPadding * Math.Max(0, numberOfButtons - 1); + var suiteWidth = buttonWidth + style.padding.right + style.padding.left; + + var rect = new Rect(buttonRect.xMax - style.margin.right - suiteWidth, buttonRect.y + style.margin.top, suiteWidth, buttonRect.height); + if (Event.current.type == EventType.Repaint) + style.Draw(rect, false, false, false, false); + buttonRect.x -= style.margin.right + style.padding.right; + return style.margin.left + style.padding.left; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineGroupGUI.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineGroupGUI.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..c021a7123e0622789e6426179319bc07af65d032 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineGroupGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 7072e9e47288bac4d8c6bdfb2cf785a4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackBaseGUI.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackBaseGUI.cs new file mode 100644 index 0000000000000000000000000000000000000000..12a4ae735972cde656c78cc79100f1bc63bae6a8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackBaseGUI.cs @@ -0,0 +1,210 @@ +using UnityEditor.IMGUI.Controls; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + abstract class TimelineTrackBaseGUI : TreeViewItem, IBounds + { + static class Styles + { + public static readonly GUIContent s_LockedAndMuted = EditorGUIUtility.TrTextContent("Locked / Muted"); + public static readonly GUIContent s_LockedAndPartiallyMuted = EditorGUIUtility.TrTextContent("Locked / Partially Muted"); + public static readonly GUIContent s_Locked = EditorGUIUtility.TrTextContent("Locked"); + public static readonly GUIContent s_Muted = EditorGUIUtility.TrTextContent("Muted"); + public static readonly GUIContent s_PartiallyMuted = EditorGUIUtility.TrTextContent("Partially Muted"); + + public static readonly GUIContent trackMuteBtnOnTooltip = EditorGUIUtility.TrTextContent(string.Empty, "Umute"); + public static readonly GUIContent trackMuteBtnOffTooltip = EditorGUIUtility.TrTextContent(string.Empty, "Mute"); + public static readonly GUIContent trackLockBtnOnTooltip = EditorGUIUtility.TrTextContent(string.Empty, "Unlock"); + public static readonly GUIContent trackLockBtnOffTooltip = EditorGUIUtility.TrTextContent(string.Empty, "Lock"); + + public static readonly Texture2D lockBg = DirectorStyles.GetBackgroundImage(DirectorStyles.Instance.trackLockOverlay); + } + + protected bool m_IsRoot = false; + + readonly TimelineTreeViewGUI m_TreeViewGUI; + readonly TrackDrawer m_Drawer; + + public Vector2 treeViewToWindowTransformation { get; set; } + public bool isExpanded { get; set; } + public bool isDropTarget { protected get; set; } + public TrackAsset track { get; } + TreeViewController treeView { get; } + + public TimelineWindow TimelineWindow + { + get + { + if (m_TreeViewGUI == null) + return null; + + return m_TreeViewGUI.TimelineWindow; + } + } + + public TrackDrawer drawer + { + get { return m_Drawer; } + } + + public virtual float GetVerticalSpacingBetweenTracks() + { + return 3.0f; + } + + public bool visibleRow { get; set; } // is the header row visible + public bool visibleExpanded { get; set; } // is the expanded area (group) visible + public bool drawInsertionMarkerBefore { get; set; } + public bool drawInsertionMarkerAfter { get; set; } + + public abstract Rect boundingRect { get; } + public abstract bool expandable { get; } + public abstract void Draw(Rect headerRect, Rect contentRect, WindowState state); + public abstract void OnGraphRebuilt(); // callback when the corresponding graph is rebuilt. This can happen, but not have the GUI rebuilt. + + protected TimelineTrackBaseGUI(int id, int depth, TreeViewItem parent, string displayName, TrackAsset trackAsset, TreeViewController tv, TimelineTreeViewGUI tvgui) + : base(id, depth, parent, displayName) + { + m_Drawer = TrackDrawer.CreateInstance(trackAsset); + m_Drawer.sequencerState = tvgui.TimelineWindow.state; + + isExpanded = false; + isDropTarget = false; + track = trackAsset; + treeView = tv; + + m_TreeViewGUI = tvgui; + } + + public static TimelineTrackBaseGUI FindGUITrack(TrackAsset track) + { + var allTracks = TimelineWindow.instance.allTracks; + return allTracks.Find(x => x.track == track); + } + + protected void DrawTrackState(Rect trackRect, Rect expandedRect, TrackAsset track) + { + if (Event.current.type == EventType.Layout) + { + bool needStateBox = false; + + //Mute + if (track.muted && !TimelineUtility.IsParentMuted(track)) + { + Rect bgRect = expandedRect; + TimelineWindow.instance.OverlayDrawData.Add(TimelineWindow.OverlayData.CreateColorOverlay(GUIClip.Unclip(bgRect), DirectorStyles.Instance.customSkin.colorTrackDarken)); + needStateBox = true; + } + + //Lock + if (!needStateBox && track.locked && !TimelineUtility.IsLockedFromGroup(track)) + { + Rect bgRect = expandedRect; + TimelineWindow.instance.OverlayDrawData.Add(TimelineWindow.OverlayData.CreateTextureOverlay(GUIClip.Unclip(bgRect), Styles.lockBg)); + needStateBox = true; + } + + if (needStateBox) + { + DrawTrackStateBox(trackRect, track); + } + } + } + + void DrawTrackStateBox(Rect trackRect, TrackAsset track) + { + const float k_LockTextPadding = 40f; + var styles = DirectorStyles.Instance; + + bool locked = track.locked && !TimelineUtility.IsLockedFromGroup(track); + bool muted = track.muted && !TimelineUtility.IsParentMuted(track); + bool allSubTrackMuted = TimelineUtility.IsAllSubTrackMuted(track); + + GUIContent content = null; + if (locked && muted) + { + content = Styles.s_LockedAndMuted; + if (!allSubTrackMuted) + content = Styles.s_LockedAndPartiallyMuted; + } + else if (locked) content = Styles.s_Locked; + else if (muted) + { + content = Styles.s_Muted; + if (!allSubTrackMuted) + content = Styles.s_PartiallyMuted; + } + + // the track could be locked, but we only show the 'locked portion' on the upper most track + // that is causing the lock + if (content == null) + return; + + var textRect = trackRect; + textRect.width = styles.fontClip.CalcSize(content).x + k_LockTextPadding; + textRect.x += (trackRect.width - textRect.width) / 2f; + textRect.height -= 4f; + textRect.y += 2f; + + + TimelineWindow.instance.OverlayDrawData.Add(TimelineWindow.OverlayData.CreateTextBoxOverlay(GUIClip.Unclip(textRect), content.text, styles.fontClip, Color.white, styles.customSkin.colorLockTextBG, styles.displayBackground)); + } + + protected void DrawMuteButton(Rect rect, WindowState state) + { + using (new EditorGUI.DisabledScope(TimelineUtility.IsParentMuted(track))) + { + EditorGUI.BeginChangeCheck(); + var isMuted = track.mutedInHierarchy; + var tooltip = isMuted ? Styles.trackMuteBtnOnTooltip : Styles.trackMuteBtnOffTooltip; + var muted = GUI.Toggle(rect, isMuted, tooltip, TimelineWindow.styles.trackMuteButton); + if (EditorGUI.EndChangeCheck()) + MuteTrack.Mute(new[] { track }, muted); + } + } + + protected void DrawLockButton(Rect rect, WindowState state) + { + using (new EditorGUI.DisabledScope(TimelineUtility.IsLockedFromGroup(track))) + { + EditorGUI.BeginChangeCheck(); + var isLocked = track.lockedInHierarchy; + var tooltip = isLocked ? Styles.trackLockBtnOnTooltip : Styles.trackLockBtnOffTooltip; + var locked = GUI.Toggle(rect, track.lockedInHierarchy, tooltip, TimelineWindow.styles.trackLockButton); + if (EditorGUI.EndChangeCheck()) + LockTrack.SetLockState(new[] { track }, locked); + } + } + + public void DrawInsertionMarkers(Rect rowRectWithIndent) + { + const float insertionHeight = WindowConstants.trackInsertionMarkerHeight; + if (Event.current.type == EventType.Repaint && (drawInsertionMarkerAfter || drawInsertionMarkerBefore)) + { + if (drawInsertionMarkerBefore) + { + var rect = new Rect(rowRectWithIndent.x, rowRectWithIndent.y - insertionHeight * 0.5f - 2.0f, rowRectWithIndent.width, insertionHeight); + EditorGUI.DrawRect(rect, Color.white); + } + + if (drawInsertionMarkerAfter) + { + var rect = new Rect(rowRectWithIndent.x, rowRectWithIndent.y + rowRectWithIndent.height - insertionHeight * 0.5f + 1.0f, rowRectWithIndent.width, insertionHeight); + EditorGUI.DrawRect(rect, Color.white); + } + } + } + + public void ClearDrawFlags() + { + if (Event.current.type == EventType.Repaint) + { + isDropTarget = false; + drawInsertionMarkerAfter = false; + drawInsertionMarkerBefore = false; + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackBaseGUI.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackBaseGUI.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..89e71a65e44be7b7d3ea0c7d1cbe3960a19386f1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackBaseGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d6b75424ba2b73c4eb3182b08dbd71ce +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackErrorGUI.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackErrorGUI.cs new file mode 100644 index 0000000000000000000000000000000000000000..7e32e2cc9622386bf2a4b35b24efe1854725afc4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackErrorGUI.cs @@ -0,0 +1,185 @@ +using System; +using UnityEditor.IMGUI.Controls; +using UnityEngine; +using UnityEngine.Playables; + +namespace UnityEditor.Timeline +{ + class TimelineTrackErrorGUI : TimelineTrackBaseGUI + { + static class Styles + { + public static readonly GUIContent ErrorText = EditorGUIUtility.TrTextContent("Track cannot be loaded.", "Please fix any compile errors in the script for this track"); + public static readonly Texture2D IconWarn = EditorGUIUtility.LoadIconRequired("console.warnicon.inactive.sml"); + public static readonly GUIContent RemoveTrack = EditorGUIUtility.TrTextContent("Delete"); + + public static readonly Color WarningBoxBackgroundColor = new Color(115.0f / 255.0f, 115.0f / 255.0f, 115.0f / 255.0f); // approved for both skins + public static readonly Color WarningBoxHighlightColor = new Color(229 / 255.0f, 208 / 255.0f, 54 / 255.0f); // brigher than standard warning color for contrast + } + + Rect m_TrackRect; + ScriptableObject m_ScriptableObject; + PlayableAsset m_Owner; + static GUIContent s_GUIContent = new GUIContent(); + + public TimelineTrackErrorGUI(TreeViewController treeview, TimelineTreeViewGUI treeviewGUI, int id, int depth, TreeViewItem parent, string displayName, ScriptableObject track, PlayableAsset owner) + : base(id, depth, parent, displayName, null, treeview, treeviewGUI) + { + m_ScriptableObject = track; + m_Owner = owner; + } + + public override Rect boundingRect + { + get { return m_TrackRect; } + } + + public override bool expandable + { + get { return false; } + } + + public override void Draw(Rect headerRect, Rect contentRect, WindowState state) + { + m_TrackRect = contentRect; + + DrawMissingTrackHeader(headerRect, state); + DrawMissingTrackBody(contentRect); + } + + void DrawMissingTrackHeader(Rect headerRect, WindowState state) + { + var styles = DirectorStyles.Instance; + + // Draw a header + Color backgroundColor = styles.customSkin.colorTrackHeaderBackground; + var bgRect = headerRect; + bgRect.x += styles.trackSwatchStyle.fixedWidth; + bgRect.width -= styles.trackSwatchStyle.fixedWidth; + EditorGUI.DrawRect(bgRect, backgroundColor); + + // draw the warning icon + var errorIcon = Styles.IconWarn; + Rect iconRect = new Rect(headerRect.xMin + styles.trackSwatchStyle.fixedWidth, headerRect.yMin + 0.5f * (headerRect.height - errorIcon.height), errorIcon.width, errorIcon.height); + if (iconRect.width > 0 && iconRect.height > 0) + { + GUI.DrawTexture(iconRect, errorIcon, ScaleMode.ScaleAndCrop, true, 0, DirectorStyles.kClipErrorColor, 0, 0); + } + + // Draw the name + + // m_ScriptableObject == null will return true because the script can't be loaded. so this checks + // to make sure it is actually not null so we can grab the name + object o = m_ScriptableObject; + if (o != null) + { + s_GUIContent.text = m_ScriptableObject.name; + var textStyle = styles.trackHeaderFont; + textStyle.normal.textColor = styles.customSkin.colorTrackFont; // TODO -- we shouldn't modify the style like this. track header does it though :( + Rect textRect = headerRect; + textRect.xMin = iconRect.xMax + 1; + textRect.xMax = Math.Min(textRect.xMin + styles.trackHeaderFont.CalcSize(s_GUIContent).x, headerRect.xMax - 1); + EditorGUI.LabelField(textRect, s_GUIContent, textStyle); + } + + + // Draw the color swatch to the left of the track, darkened by the mute + var color = Color.Lerp(DirectorStyles.kClipErrorColor, styles.customSkin.colorTrackDarken, styles.customSkin.colorTrackDarken.a); + color.a = 1; + using (new GUIColorOverride(color)) + { + var colorSwatchRect = headerRect; + colorSwatchRect.width = styles.trackSwatchStyle.fixedWidth; + GUI.Label(colorSwatchRect, GUIContent.none, styles.trackSwatchStyle); + } + + // draw darken overlay + EditorGUI.DrawRect(bgRect, styles.customSkin.colorTrackDarken); + + DrawRemoveMenu(headerRect, state); + } + + void DrawRemoveMenu(Rect headerRect, WindowState state) + { + const float pad = 3; + const float buttonSize = 16; + var buttonRect = new Rect(headerRect.xMax - buttonSize - pad, headerRect.y + ((headerRect.height - buttonSize) / 2f) + 2, buttonSize, buttonSize); + + if (GUI.Button(buttonRect, GUIContent.none, DirectorStyles.Instance.trackOptions)) + { + GenericMenu menu = new GenericMenu(); + + var owner = m_Owner; + var scriptableObject = m_ScriptableObject; + + menu.AddItem(Styles.RemoveTrack, false, () => + { + if (TrackExtensions.RemoveBrokenTrack(owner, scriptableObject)) + state.Refresh(); + } + ); + + menu.ShowAsContext(); + } + } + + static void DrawMissingTrackBody(Rect contentRect) + { + if (contentRect.width < 0) + return; + + var styles = DirectorStyles.Instance; + + // draw a track rectangle + EditorGUI.DrawRect(contentRect, styles.customSkin.colorTrackDarken); + // draw the warning box + DrawScriptWarningBox(contentRect, Styles.ErrorText); + } + + static void DrawScriptWarningBox(Rect trackRect, GUIContent content) + { + var styles = DirectorStyles.Instance; + const float kTextPadding = 52f; + + var errorIcon = Styles.IconWarn; + float textWidth = styles.fontClip.CalcSize(content).x; + + var outerRect = trackRect; + outerRect.width = textWidth + kTextPadding + errorIcon.width; + outerRect.x += (trackRect.width - outerRect.width) / 2f; + outerRect.height -= 4f; + outerRect.y += 1f; + + bool drawText = true; + if (outerRect.width > trackRect.width) + { + outerRect.x = trackRect.x; + outerRect.width = trackRect.width; + drawText = false; + } + + var innerRect = new Rect(outerRect.x + 2, outerRect.y + 2, outerRect.width - 4, outerRect.height - 4); + using (new GUIColorOverride(Styles.WarningBoxHighlightColor)) + GUI.Box(outerRect, GUIContent.none, styles.displayBackground); + using (new GUIColorOverride(Styles.WarningBoxBackgroundColor)) + GUI.Box(innerRect, GUIContent.none, styles.displayBackground); + + + if (drawText) + { + var iconRect = new Rect(outerRect.x + kTextPadding / 2.0f - 4.0f, outerRect.y + (outerRect.height - errorIcon.height) / 2.0f, errorIcon.width, errorIcon.height); + var textRect = new Rect(iconRect.xMax + 4.0f, outerRect.y, textWidth, outerRect.height); + + GUI.DrawTexture(iconRect, errorIcon, ScaleMode.ScaleAndCrop, true, 0, Styles.WarningBoxHighlightColor, 0, 0); + Graphics.ShadowLabel(textRect, content, styles.fontClip, Color.white, Color.black); + } + else if (errorIcon.width > innerRect.width) + { + var iconRect = new Rect(outerRect.x + (outerRect.width - errorIcon.width) / 2.0f, outerRect.y + (outerRect.height - errorIcon.height) / 2.0f, errorIcon.width, errorIcon.height); + GUI.DrawTexture(iconRect, errorIcon, ScaleMode.ScaleAndCrop, true, 0, Styles.WarningBoxHighlightColor, 0, 0); + } + } + + public override void OnGraphRebuilt() {} + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackErrorGUI.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackErrorGUI.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..ccdc4875fad5195aa3a23527a14f954ee10a62fa --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackErrorGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e00dc5a0cda466b41b09a50bd18b4916 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackGUI.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackGUI.cs new file mode 100644 index 0000000000000000000000000000000000000000..46673da0ea7606a718d07efebccf88d8aac09bb9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackGUI.cs @@ -0,0 +1,859 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor.IMGUI.Controls; +using UnityEngine; +using UnityEngine.Timeline; +using UnityEngine.Playables; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class TimelineTrackGUI : TimelineGroupGUI, IClipCurveEditorOwner, IRowGUI + { + struct TrackDrawData + { + public bool m_AllowsRecording; + public bool m_ShowTrackBindings; + public bool m_HasBinding; + public bool m_IsSubTrack; + public PlayableBinding m_Binding; + public Object m_TrackBinding; + public Texture m_TrackIcon; + public bool m_HasMarkers; + } + + static class Styles + { + public static readonly GUIContent trackCurvesBtnOnTooltip = DirectorStyles.TrTextContent(string.Empty, "Hide curves view"); + public static readonly GUIContent trackCurvesBtnOffTooltip = DirectorStyles.TrTextContent(string.Empty, "Show curves view"); + public static readonly GUIContent trackMarkerBtnOnTooltip = DirectorStyles.TrTextContent(string.Empty, "Collapse Track Markers"); + public static readonly GUIContent trackMarkerBtnOffTooltip = DirectorStyles.TrTextContent(string.Empty, "Expand Track Markers"); + + public static readonly GUIContent kActiveRecordButtonTooltip = DirectorStyles.TrTextContent(string.Empty, "End recording"); + public static readonly GUIContent kInactiveRecordButtonTooltip = DirectorStyles.TrTextContent(string.Empty, "Start recording"); + public static readonly GUIContent kIgnorePreviewRecordButtonTooltip = DirectorStyles.TrTextContent(string.Empty, "Recording is disabled: scene preview is ignored for this TimelineAsset"); + public static readonly GUIContent kDisabledRecordButtonTooltip = DirectorStyles.TrTextContent(string.Empty, + "Recording is not permitted when Track Offsets are set to Auto. Track Offset settings can be changed in the track menu of the base track."); + public static Texture2D kProblemIcon = DirectorStyles.GetBackgroundImage(DirectorStyles.Instance.warning); + } + + static GUIContent s_ArmForRecordContentOn; + static GUIContent s_ArmForRecordContentOff; + static GUIContent s_ArmForRecordDisabled; + + readonly InfiniteTrackDrawer m_InfiniteTrackDrawer; + readonly TrackEditor m_TrackEditor; + readonly GUIContent m_DefaultTrackIcon; + readonly TrackResizeHandle m_ResizeHandle; + + TrackItemsDrawer m_ItemsDrawer; + TrackDrawData m_TrackDrawData; + TrackDrawOptions m_TrackDrawOptions; + + bool m_InlineCurvesSkipped; + int m_TrackHash = -1; + int m_BlendHash = -1; + int m_LastDirtyIndex = -1; + + bool? m_TrackHasAnimatableParameters; + int m_HeightExtension; + + public override bool expandable + { + get { return hasChildren; } + } + + internal InlineCurveEditor inlineCurveEditor { get; set; } + + public ClipCurveEditor clipCurveEditor { get; private set; } + + public bool inlineCurvesSelected => SelectionManager.IsCurveEditorFocused(this); + + bool IClipCurveEditorOwner.showLoops + { + get { return false; } + } + + TrackAsset IClipCurveEditorOwner.owner + { + get { return track; } + } + + static bool DoesTrackAllowsRecording(TrackAsset track) + { + // if the root animation track is in auto mode, recording is not allowed + var animTrack = TimelineUtility.GetSceneReferenceTrack(track) as AnimationTrack; + if (animTrack != null) + return animTrack.trackOffset != TrackOffset.Auto; + + return false; + } + + bool trackHasAnimatableParameters + { + get + { + // cache this value to avoid the recomputation + if (!m_TrackHasAnimatableParameters.HasValue) + m_TrackHasAnimatableParameters = track.HasAnyAnimatableParameters() || + track.clips.Any(c => c.HasAnyAnimatableParameters()); + + return m_TrackHasAnimatableParameters.Value; + } + } + + public bool locked + { + get { return track.lockedInHierarchy; } + } + + public bool showMarkers + { + get { return track.GetShowMarkers(); } + } + + public bool muted + { + get { return track.muted; } + } + + public List clips + { + get + { + return m_ItemsDrawer.clips == null ? new List(0) : m_ItemsDrawer.clips; + } + } + + TrackAsset IRowGUI.asset { get { return track; } } + + bool showTrackRecordingDisabled + { + get + { + // if the root animation track is in auto mode, recording is not allowed + var animTrack = TimelineUtility.GetSceneReferenceTrack(track) as AnimationTrack; + return animTrack != null && animTrack.trackOffset == TrackOffset.Auto; + } + } + + public int heightExtension + { + get => m_HeightExtension; + set => m_HeightExtension = Math.Max(0, value); + } + + float minimumHeight => m_TrackDrawOptions.minimumHeight <= 0.0f ? TrackEditor.DefaultTrackHeight : m_TrackDrawOptions.minimumHeight; + + public TimelineTrackGUI(TreeViewController tv, TimelineTreeViewGUI w, int id, int depth, TreeViewItem parent, string displayName, TrackAsset sequenceActor) + : base(tv, w, id, depth, parent, displayName, sequenceActor, false) + { + var animationTrack = sequenceActor as AnimationTrack; + if (animationTrack != null) + m_InfiniteTrackDrawer = new InfiniteTrackDrawer(new AnimationTrackKeyDataSource(animationTrack)); + else if (sequenceActor.HasAnyAnimatableParameters() && !sequenceActor.clips.Any()) + m_InfiniteTrackDrawer = new InfiniteTrackDrawer(new TrackPropertyCurvesDataSource(sequenceActor)); + + UpdateInfiniteClipEditor(w.TimelineWindow); + + var bindings = track.outputs.ToArray(); + m_TrackDrawData.m_HasBinding = bindings.Length > 0; + if (m_TrackDrawData.m_HasBinding) + m_TrackDrawData.m_Binding = bindings[0]; + m_TrackDrawData.m_IsSubTrack = IsSubTrack(); + m_TrackDrawData.m_AllowsRecording = DoesTrackAllowsRecording(sequenceActor); + m_TrackDrawData.m_HasMarkers = track.GetMarkerCount() > 0; + m_DefaultTrackIcon = TrackResourceCache.GetTrackIcon(track); + + m_TrackEditor = CustomTimelineEditorCache.GetTrackEditor(sequenceActor); + + try + { + m_TrackDrawOptions = m_TrackEditor.GetTrackOptions(track, null); + } + catch (Exception e) + { + Debug.LogException(e); + m_TrackDrawOptions = CustomTimelineEditorCache.GetDefaultTrackEditor().GetTrackOptions(track, null); + } + + m_TrackDrawOptions.errorText = null; // explicitly setting to null for an uninitialized state + m_ResizeHandle = new TrackResizeHandle(this); + heightExtension = TimelineWindowViewPrefs.GetTrackHeightExtension(track); + + RebuildGUICacheIfNecessary(); + } + + public override float GetVerticalSpacingBetweenTracks() + { + if (track != null && track.isSubTrack) + return 1.0f; // subtracks have less of a gap than tracks + return base.GetVerticalSpacingBetweenTracks(); + } + + void UpdateInfiniteClipEditor(TimelineWindow window) + { + if (clipCurveEditor != null || track == null || !ShouldShowInfiniteClipEditor()) + return; + + var dataSource = CurveDataSource.Create(this); + clipCurveEditor = new ClipCurveEditor(dataSource, window, track); + } + + void DetectTrackChanged() + { + if (Event.current.type == EventType.Layout) + { + // incremented when a track or it's clips changed + if (m_LastDirtyIndex != track.DirtyIndex) + { + try + { + m_TrackEditor.OnTrackChanged(track); + } + catch (Exception e) + { + Debug.LogException(e); + } + m_LastDirtyIndex = track.DirtyIndex; + } + OnTrackChanged(); + } + } + + // Called when the source track data, including it's clips have changed has changed. + void OnTrackChanged() + { + // recompute blends if necessary + int newBlendHash = BlendHash(); + if (m_BlendHash != newBlendHash) + { + UpdateClipOverlaps(); + m_BlendHash = newBlendHash; + } + + RebuildGUICacheIfNecessary(); + } + + void UpdateDrawData(WindowState state) + { + if (Event.current.type == EventType.Layout) + { + m_TrackDrawData.m_ShowTrackBindings = false; + m_TrackDrawData.m_TrackBinding = null; + + if (state.editSequence.director != null && showSceneReference) + { + m_TrackDrawData.m_ShowTrackBindings = state.GetWindow().currentMode.ShouldShowTrackBindings(state); + m_TrackDrawData.m_TrackBinding = state.editSequence.director.GetGenericBinding(track); + } + + var lastHeight = m_TrackDrawOptions.minimumHeight; + try + { + m_TrackDrawOptions = m_TrackEditor.GetTrackOptions(track, m_TrackDrawData.m_TrackBinding); + } + catch (Exception e) + { + Debug.LogException(e); + m_TrackDrawOptions = CustomTimelineEditorCache.GetDefaultTrackEditor().GetTrackOptions(track, m_TrackDrawData.m_TrackBinding); + } + + m_TrackDrawData.m_HasMarkers = track.GetMarkerCount() > 0; + m_TrackDrawData.m_AllowsRecording = DoesTrackAllowsRecording(track); + m_TrackDrawData.m_TrackIcon = m_TrackDrawOptions.icon; + if (m_TrackDrawData.m_TrackIcon == null) + m_TrackDrawData.m_TrackIcon = m_DefaultTrackIcon.image; + + // track height has changed. need to update gui + if (!Mathf.Approximately(lastHeight, m_TrackDrawOptions.minimumHeight)) + state.Refresh(); + } + } + + public override void Draw(Rect headerRect, Rect contentRect, WindowState state) + { + DetectTrackChanged(); + UpdateDrawData(state); + + UpdateInfiniteClipEditor(state.GetWindow()); + + var trackHeaderRect = headerRect; + var trackContentRect = contentRect; + + float inlineCurveHeight = contentRect.height - GetTrackContentHeight(state); + bool hasInlineCurve = inlineCurveHeight > 0.0f; + + if (hasInlineCurve) + { + trackHeaderRect.height -= inlineCurveHeight; + trackContentRect.height -= inlineCurveHeight; + } + + if (Event.current.type == EventType.Repaint) + { + m_TreeViewRect = trackContentRect; + } + + track.SetCollapsed(!isExpanded); + + RebuildGUICacheIfNecessary(); + + // Prevents from drawing outside of bounds, but does not effect layout or markers + bool isOwnerDrawSucceed = false; + + Vector2 visibleTime = state.timeAreaShownRange; + + if (drawer != null) + isOwnerDrawSucceed = drawer.DrawTrack(trackContentRect, track, visibleTime, state); + + if (!isOwnerDrawSucceed) + { + using (new GUIViewportScope(trackContentRect)) + DrawBackground(trackContentRect, track, visibleTime, state); + + if (m_InfiniteTrackDrawer != null) + m_InfiniteTrackDrawer.DrawTrack(trackContentRect, track, visibleTime, state); + + // draw after user customization so overlay text shows up + using (new GUIViewportScope(trackContentRect)) + m_ItemsDrawer.Draw(trackContentRect, state); + } + + DrawTrackHeader(trackHeaderRect, state); + + if (hasInlineCurve) + { + var curvesHeaderRect = headerRect; + curvesHeaderRect.yMin = trackHeaderRect.yMax; + + var curvesContentRect = contentRect; + curvesContentRect.yMin = trackContentRect.yMax; + + DrawInlineCurves(curvesHeaderRect, curvesContentRect, state); + } + + DrawTrackColorKind(headerRect); + DrawTrackState(contentRect, contentRect, track); + } + + void DrawInlineCurves(Rect curvesHeaderRect, Rect curvesContentRect, WindowState state) + { + if (!track.GetShowInlineCurves()) + return; + + // Inline curves are not within the editor window -- case 952571 + if (!IsInlineCurvesEditorInBounds(ToWindowSpace(curvesHeaderRect), curvesContentRect.height, state)) + { + m_InlineCurvesSkipped = true; + return; + } + + // If inline curves were skipped during the last event; we want to avoid rendering them until + // the next Layout event. Otherwise, we still get the RTE prevented above when the user resizes + // the timeline window very fast. -- case 952571 + if (m_InlineCurvesSkipped && Event.current.type != EventType.Layout) + return; + + m_InlineCurvesSkipped = false; + + if (inlineCurveEditor == null) + inlineCurveEditor = new InlineCurveEditor(this); + + + curvesHeaderRect.x += DirectorStyles.kBaseIndent; + curvesHeaderRect.width -= DirectorStyles.kBaseIndent; + + inlineCurveEditor.Draw(curvesHeaderRect, curvesContentRect, state); + } + + static bool IsInlineCurvesEditorInBounds(Rect windowSpaceTrackRect, float inlineCurveHeight, WindowState state) + { + var legalHeight = state.windowHeight; + var trackTop = windowSpaceTrackRect.y; + var inlineCurveOffset = windowSpaceTrackRect.height - inlineCurveHeight; + return legalHeight - trackTop - inlineCurveOffset > 0; + } + + void DrawErrorIcon(Rect position, WindowState state) + { + Rect bindingLabel = position; + bindingLabel.x = position.xMax + 3; + bindingLabel.width = state.bindingAreaWidth; + EditorGUI.LabelField(position, m_ProblemIcon); + } + + void DrawBackground(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state) + { + bool canDrawRecordBackground = IsRecording(state); + if (canDrawRecordBackground) + { + DrawRecordingTrackBackground(trackRect, trackAsset, visibleTime, state); + } + else + { + Color trackBackgroundColor; + + if (SelectionManager.Contains(track)) + { + trackBackgroundColor = state.IsEditingASubTimeline() ? + DirectorStyles.Instance.customSkin.colorTrackSubSequenceBackgroundSelected : + DirectorStyles.Instance.customSkin.colorTrackBackgroundSelected; + } + else + { + trackBackgroundColor = state.IsEditingASubTimeline() ? + DirectorStyles.Instance.customSkin.colorTrackSubSequenceBackground : + DirectorStyles.Instance.customSkin.colorTrackBackground; + } + + EditorGUI.DrawRect(trackRect, trackBackgroundColor); + } + } + + float InlineCurveHeight() + { + return track.GetShowInlineCurves() && CanDrawInlineCurve() + ? TimelineWindowViewPrefs.GetInlineCurveHeight(track) + : 0.0f; + } + + public override float GetHeight(WindowState state) + { + var height = GetTrackContentHeight(state); + + if (CanDrawInlineCurve()) + height += InlineCurveHeight(); + + return height; + } + + float GetTrackContentHeight(WindowState state) + { + var defaultHeight = Mathf.Min(minimumHeight, TrackEditor.MaximumTrackHeight); + return (defaultHeight + heightExtension) * state.trackScale; + } + + static bool CanDrawIcon(GUIContent icon) + { + return icon != null && icon != GUIContent.none && icon.image != null; + } + + bool showSceneReference + { + get + { + return track != null && + m_TrackDrawData.m_HasBinding && + !m_TrackDrawData.m_IsSubTrack && + m_TrackDrawData.m_Binding.sourceObject != null && + m_TrackDrawData.m_Binding.outputTargetType != null && + typeof(Object).IsAssignableFrom(m_TrackDrawData.m_Binding.outputTargetType); + } + } + + void DrawTrackHeader(Rect trackHeaderRect, WindowState state) + { + using (new GUIViewportScope(trackHeaderRect)) + { + var rect = trackHeaderRect; + + DrawHeaderBackground(trackHeaderRect); + rect.x += m_Styles.trackSwatchStyle.fixedWidth; + + const float buttonSize = WindowConstants.trackHeaderButtonSize; + const float padding = WindowConstants.trackHeaderButtonPadding; + var buttonRect = new Rect(trackHeaderRect.xMax - buttonSize - padding, rect.y + (rect.height - buttonSize) / 2f, buttonSize, buttonSize); + + rect.x += DrawTrackIconKind(rect, state); + + if (track is GroupTrack) + return; + + buttonRect.x -= DrawTrackDropDownMenu(buttonRect); + var suiteRect = DrawGeneralSuite(state, buttonRect); + suiteRect = DrawCustomSuite(state, suiteRect); + + var bindingRect = new Rect(rect.x, rect.y, suiteRect.xMax - rect.x, rect.height); + DrawTrackBinding(bindingRect, trackHeaderRect); + } + + m_ResizeHandle.Draw(trackHeaderRect, state); + } + + Rect DrawGeneralSuite(WindowState state, Rect rect) + { + const float buttonWidth = WindowConstants.trackHeaderButtonSize + WindowConstants.trackHeaderButtonPadding; + var padding = DrawButtonSuite(3, ref rect); + + DrawMuteButton(rect, state); + rect.x -= buttonWidth; + DrawLockButton(rect, state); + rect.x -= buttonWidth; + DrawLockMarkersButton(rect, state); + rect.x -= buttonWidth; + + rect.x -= padding; + return rect; + } + + Rect DrawCustomSuite(WindowState state, Rect rect) + { + var numberOfButtons = 0; + if (m_TrackDrawData.m_AllowsRecording || showTrackRecordingDisabled) + numberOfButtons++; + if (CanDrawInlineCurve()) + numberOfButtons++; + if (drawer.HasCustomTrackHeaderButton()) + numberOfButtons++; + if (numberOfButtons == 0) + return rect; + + var padding = DrawButtonSuite(numberOfButtons, ref rect); + + rect.x -= DrawRecordButton(rect, state); + rect.x -= DrawInlineCurveButton(rect, state); + rect.x -= DrawCustomTrackButton(rect, state); + rect.x -= padding; + return rect; + } + + void DrawHeaderBackground(Rect headerRect) + { + Color backgroundColor = SelectionManager.Contains(track) + ? DirectorStyles.Instance.customSkin.colorSelection + : DirectorStyles.Instance.customSkin.colorTrackHeaderBackground; + + var bgRect = headerRect; + bgRect.x += m_Styles.trackSwatchStyle.fixedWidth; + bgRect.width -= m_Styles.trackSwatchStyle.fixedWidth; + + EditorGUI.DrawRect(bgRect, backgroundColor); + } + + void DrawTrackColorKind(Rect rect) + { + // subtracks don't draw the color, the parent does that. + if (track != null && track.isSubTrack) + return; + + if (rect.width <= 0) return; + + using (new GUIColorOverride(m_TrackDrawOptions.trackColor)) + { + rect.width = m_Styles.trackSwatchStyle.fixedWidth; + GUI.Label(rect, GUIContent.none, m_Styles.trackSwatchStyle); + } + } + + float DrawTrackIconKind(Rect rect, WindowState state) + { + // no icons on subtracks + if (track != null && track.isSubTrack) + return 0.0f; + + rect.yMin += (rect.height - 16f) / 2f; + rect.width = 16.0f; + rect.height = 16.0f; + + if (!string.IsNullOrEmpty(m_TrackDrawOptions.errorText)) + { + m_ProblemIcon.image = Styles.kProblemIcon; + m_ProblemIcon.tooltip = m_TrackDrawOptions.errorText; + + if (CanDrawIcon(m_ProblemIcon)) + DrawErrorIcon(rect, state); + } + else + { + var content = GUIContent.Temp(m_TrackDrawData.m_TrackIcon, m_DefaultTrackIcon.tooltip); + if (CanDrawIcon(content)) + GUI.Box(rect, content, GUIStyle.none); + } + + return rect.width; + } + + void DrawTrackBinding(Rect rect, Rect headerRect) + { + if (m_TrackDrawData.m_ShowTrackBindings) + { + DoTrackBindingGUI(rect); + return; + } + + var textStyle = m_Styles.trackHeaderFont; + textStyle.normal.textColor = SelectionManager.Contains(track) ? Color.white : m_Styles.customSkin.colorTrackFont; + + string trackName = track.name; + + EditorGUI.BeginChangeCheck(); + + // by default the size is just the width of the string (for selection purposes) + rect.width = m_Styles.trackHeaderFont.CalcSize(new GUIContent(trackName)).x; + + // if we are editing, supply the entire width of the header + if (GUIUtility.keyboardControl == track.GetInstanceID()) + rect.width = (headerRect.xMax - rect.xMin) - (5 * WindowConstants.trackHeaderButtonSize); + + trackName = EditorGUI.DelayedTextField(rect, GUIContent.none, track.GetInstanceID(), track.name, textStyle); + + if (EditorGUI.EndChangeCheck()) + { + UndoExtensions.RegisterTrack(track, "Rename Track"); + track.name = trackName; + } + } + + float DrawTrackDropDownMenu(Rect rect) + { + if (GUI.Button(rect, GUIContent.none, m_Styles.trackOptions)) + { + // the drop down will apply to all selected tracks + if (!SelectionManager.Contains(track)) + { + SelectionManager.Clear(); + SelectionManager.Add(track); + } + + SequencerContextMenu.ShowTrackContextMenu(null); + } + + return WindowConstants.trackHeaderButtonSize; + } + + bool CanDrawInlineCurve() + { + // Note: A track with animatable parameters always has inline curves. + return trackHasAnimatableParameters || TimelineUtility.TrackHasAnimationCurves(track); + } + + float DrawInlineCurveButton(Rect rect, WindowState state) + { + if (!CanDrawInlineCurve()) + { + //Force to close Inline Curve UI if the inline cannot be drawn. + if (track.GetShowInlineCurves()) + track.SetShowInlineCurves(false); + return 0.0f; + } + + // Override enable state to display "Show Inline Curves" button in disabled state. + bool prevEnabledState = GUI.enabled; + GUI.enabled = true; + var showInlineCurves = track.GetShowInlineCurves(); + var tooltip = showInlineCurves ? Styles.trackCurvesBtnOnTooltip : Styles.trackCurvesBtnOffTooltip; + var newValue = GUI.Toggle(rect, track.GetShowInlineCurves(), tooltip, DirectorStyles.Instance.trackCurvesButton); + GUI.enabled = prevEnabledState; + + if (newValue != track.GetShowInlineCurves()) + { + track.SetShowInlineCurves(newValue); + state.GetWindow().treeView.CalculateRowRects(); + } + + return WindowConstants.trackHeaderButtonSize + WindowConstants.trackHeaderButtonPadding; + } + + float DrawRecordButton(Rect rect, WindowState state) + { + var style = DirectorStyles.Instance.trackRecordButton; + const float buttonWidth = WindowConstants.trackHeaderButtonSize + WindowConstants.trackHeaderButtonPadding; + + if (m_TrackDrawData.m_AllowsRecording) + { + bool isPlayerDisabled = state.editSequence.director != null && !state.editSequence.director.isActiveAndEnabled; + + GameObject goBinding = m_TrackDrawData.m_TrackBinding as GameObject; + if (goBinding == null) + { + Component c = m_TrackDrawData.m_TrackBinding as Component; + if (c != null) + goBinding = c.gameObject; + } + + if (goBinding == null && m_TrackDrawData.m_IsSubTrack) + goBinding = ParentTrack().GetGameObjectBinding(state.editSequence.director); + + var isTrackBindingValid = goBinding != null; + var trackErrorDisableButton = !string.IsNullOrEmpty(m_TrackDrawOptions.errorText) && isTrackBindingValid && goBinding.activeInHierarchy; + var disableButton = track.lockedInHierarchy || isPlayerDisabled || trackErrorDisableButton || !isTrackBindingValid || state.ignorePreview; + using (new EditorGUI.DisabledScope(disableButton)) + { + if (IsRecording(state)) + { + state.editorWindow.Repaint(); + var remainder = Time.realtimeSinceStartup % 1; + + if (remainder < 0.22f) + style = GUIStyle.none; + if (GUI.Button(rect, Styles.kActiveRecordButtonTooltip, style) || isPlayerDisabled || !isTrackBindingValid) + state.UnarmForRecord(track); + } + else if (!track.timelineAsset.editorSettings.scenePreview) + GUI.Button(rect, Styles.kIgnorePreviewRecordButtonTooltip, style); + else + { + if (GUI.Button(rect, Styles.kInactiveRecordButtonTooltip, style)) + state.ArmForRecord(track); + } + return buttonWidth; + } + } + + if (showTrackRecordingDisabled) + { + using (new EditorGUI.DisabledScope(true)) + GUI.Button(rect, Styles.kDisabledRecordButtonTooltip, style); + return buttonWidth; + } + + return 0.0f; + } + + float DrawCustomTrackButton(Rect rect, WindowState state) + { + if (!drawer.HasCustomTrackHeaderButton()) + return 0.0f; + + drawer.DrawTrackHeaderButton(rect, state); + return WindowConstants.trackHeaderButtonSize + WindowConstants.trackHeaderButtonPadding; + } + + void DrawLockMarkersButton(Rect rect, WindowState state) + { + var hasMarkers = track.GetMarkerCount() != 0; + var markersShown = showMarkers && hasMarkers; + var style = TimelineWindow.styles.trackMarkerButton; + + EditorGUI.BeginChangeCheck(); + var tooltip = markersShown ? Styles.trackMarkerBtnOnTooltip : Styles.trackMarkerBtnOffTooltip; + var toggleMarkers = GUI.Toggle(rect, markersShown, tooltip, style); + if (EditorGUI.EndChangeCheck() && hasMarkers) + track.SetShowTrackMarkers(toggleMarkers); + } + + static void ObjectBindingField(Rect position, Object obj, PlayableBinding binding) + { + var allowScene = + typeof(GameObject).IsAssignableFrom(binding.outputTargetType) || + typeof(Component).IsAssignableFrom(binding.outputTargetType); + + var bindingFieldRect = EditorGUI.IndentedRect(position); + using (new GUIViewportScope(bindingFieldRect)) + { + using (var check = new EditorGUI.ChangeCheckScope()) + { + // FocusType.Passive so it never gets focused when pressing tab + int controlId = GUIUtility.GetControlID("s_ObjectFieldHash".GetHashCode(), FocusType.Passive, position); + var newObject = UnityEditorInternals.DoObjectField(EditorGUI.IndentedRect(position), obj, binding.outputTargetType, controlId, allowScene); + if (check.changed) + { + BindingUtility.Bind(TimelineEditor.inspectedDirector, binding.sourceObject as TrackAsset, newObject); + } + } + } + } + + void DoTrackBindingGUI(Rect rect) + { + var bindingRect = new Rect( + rect.xMin, + rect.y + (rect.height - WindowConstants.trackHeaderButtonSize) / 2f, + Mathf.Min(rect.width, WindowConstants.trackBindingMaxSize) - WindowConstants.trackBindingPadding, + WindowConstants.trackHeaderButtonSize); + + if (bindingRect.Contains(Event.current.mousePosition) && TimelineDragging.IsDraggingEvent() && DragAndDrop.objectReferences.Length == 1) + { + TimelineDragging.HandleBindingDragAndDrop(track, BindingUtility.GetRequiredBindingType(m_TrackDrawData.m_Binding)); + Event.current.Use(); + } + else + { + if (m_TrackDrawData.m_Binding.outputTargetType != null && typeof(Object).IsAssignableFrom(m_TrackDrawData.m_Binding.outputTargetType)) + { + ObjectBindingField(bindingRect, m_TrackDrawData.m_TrackBinding, m_TrackDrawData.m_Binding); + } + } + } + + bool IsRecording(WindowState state) + { + return state.recording && state.IsArmedForRecord(track); + } + + // background to draw during recording + void DrawRecordingTrackBackground(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state) + { + if (drawer != null) + drawer.DrawRecordingBackground(trackRect, trackAsset, visibleTime, state); + } + + void UpdateClipOverlaps() + { + TrackExtensions.ComputeBlendsFromOverlaps(track.clips); + } + + internal void RebuildGUICacheIfNecessary() + { + if (m_TrackHash == track.Hash()) + return; + + m_ItemsDrawer = new TrackItemsDrawer(this); + m_TrackHash = track.Hash(); + } + + int BlendHash() + { + var hash = 0; + foreach (var clip in track.clips) + { + hash = HashUtility.CombineHash(hash, + (clip.duration - clip.start).GetHashCode(), + ((int)clip.blendInCurveMode).GetHashCode(), + ((int)clip.blendOutCurveMode).GetHashCode()); + } + return hash; + } + + // callback when the corresponding graph is rebuilt. This can happen, but not have the GUI rebuilt. + public override void OnGraphRebuilt() + { + RefreshCurveEditor(); + } + + void RefreshCurveEditor() + { + var window = TimelineWindow.instance; + if (track != null && window != null && window.state != null) + { + bool hasEditor = clipCurveEditor != null; + bool shouldHaveEditor = ShouldShowInfiniteClipEditor(); + if (hasEditor != shouldHaveEditor) + window.state.AddEndFrameDelegate((x, currentEvent) => + { + x.Refresh(); + return true; + }); + } + } + + bool ShouldShowInfiniteClipEditor() + { + var animationTrack = track as AnimationTrack; + if (animationTrack != null) + return animationTrack.ShouldShowInfiniteClipEditor(); + + return trackHasAnimatableParameters; + } + + public void SelectCurves() + { + SelectionManager.RemoveTimelineSelection(); + SelectionManager.SelectInlineCurveEditor(this); + } + + public void ValidateCurvesSelection() {} + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackGUI.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackGUI.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..f6c6e346be6294ae483ee3a478c948666ef8083d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TimelineTrackGUI.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b3b27007577486c4d8dc088f989b288c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TrackResizeHandle.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TrackResizeHandle.cs new file mode 100644 index 0000000000000000000000000000000000000000..12e25d27bbee083ebb22762e64172177d1ce3697 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TrackResizeHandle.cs @@ -0,0 +1,29 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class TrackResizeHandle : IBounds + { + public Rect boundingRect { get; private set; } + + public TimelineTrackGUI trackGUI { get; } + + public TrackResizeHandle(TimelineTrackGUI trackGUI) + { + this.trackGUI = trackGUI; + } + + public void Draw(Rect headerRect, WindowState state) + { + const float resizeHandleHeight = WindowConstants.trackResizeHandleHeight; + var rect = new Rect(headerRect.xMin, headerRect.yMax - (0.5f * resizeHandleHeight), headerRect.width, resizeHandleHeight); + boundingRect = trackGUI.ToWindowSpace(rect); + + var cursorRect = rect; + cursorRect.height--; + EditorGUIUtility.AddCursorRect(cursorRect, MouseCursor.SplitResizeUpDown); + if (Event.current.type == EventType.Repaint) + state.headerSpacePartitioner.AddBounds(this); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TrackResizeHandle.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TrackResizeHandle.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..fcd4f94e9d1c26db1947132d10a604a81ff20d23 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackGui/TrackResizeHandle.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 042c802f94d43dc45a049bf3b5be79ab +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackPropertyCurvesDataSource.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackPropertyCurvesDataSource.cs new file mode 100644 index 0000000000000000000000000000000000000000..4b808ea79d480034b2966eedc3965c096b276561 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackPropertyCurvesDataSource.cs @@ -0,0 +1,15 @@ +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TrackPropertyCurvesDataSource : BasePropertyKeyDataSource + { + protected override AnimationClip animationClip { get; } + + public TrackPropertyCurvesDataSource(TrackAsset track) + { + animationClip = track != null ? track.curves : null; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackPropertyCurvesDataSource.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackPropertyCurvesDataSource.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..fc351b4f83ca89d7f117438b626228d18cfda7cb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/treeview/TrackPropertyCurvesDataSource.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f8964ef46e1d446dc9eb17a36a3e1f14 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/CustomSignalEventDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/CustomSignalEventDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..49df674107e733cf677d77b0c2e89cc5d5a39af1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/CustomSignalEventDrawer.cs @@ -0,0 +1,5 @@ +namespace UnityEngine.Timeline +{ + //used to tell Signal Handler inspector to use a special drawer for UnityEvent + class CustomSignalEventDrawer : PropertyAttribute {} +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/CustomSignalEventDrawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/CustomSignalEventDrawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..c7c813f0a62b8e8320db4a3a7e5f9db36b0fcd43 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/CustomSignalEventDrawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a7ebd1239373d5f41af65ef32d67f445 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalAsset.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalAsset.cs new file mode 100644 index 0000000000000000000000000000000000000000..d6055889e8dfd684d790c7ba5ed85e04f8e5c9a0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalAsset.cs @@ -0,0 +1,22 @@ +using System; +using UnityEngine; + +namespace UnityEngine.Timeline +{ + /// + /// An asset representing an emitted signal. A SignalAsset connects a SignalEmitter with a SignalReceiver. + /// + /// + /// + [AssetFileNameExtension("signal")] + public class SignalAsset : ScriptableObject + { + internal static event Action OnEnableCallback; + + void OnEnable() + { + if (OnEnableCallback != null) + OnEnableCallback(this); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalAsset.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalAsset.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..437f4d3102d9ebd0dddbe34d7a42dd57f6e65931 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalAsset.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d6fa2d92fc1b3f34da284357edf89c3b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalEmitter.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalEmitter.cs new file mode 100644 index 0000000000000000000000000000000000000000..fc1e0b6f445013889b456bee8716396a8bcf23e2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalEmitter.cs @@ -0,0 +1,72 @@ +using System; +using UnityEngine; +using UnityEngine.Playables; + +namespace UnityEngine.Timeline +{ + /// + /// Marker that emits a signal to a SignalReceiver. + /// + /// A SignalEmitter emits a notification through the playable system. A SignalEmitter is used with a SignalReceiver and a SignalAsset. + /// + /// + /// + [Serializable] + [CustomStyle("SignalEmitter")] + [ExcludeFromPreset] + public class SignalEmitter : Marker, INotification, INotificationOptionProvider + { + [SerializeField] bool m_Retroactive; + [SerializeField] bool m_EmitOnce; + [SerializeField] SignalAsset m_Asset; + + /// + /// Use retroactive to emit the signal if playback starts after the SignalEmitter time. + /// + public bool retroactive + { + get { return m_Retroactive; } + set { m_Retroactive = value; } + } + + /// + /// Use emitOnce to emit this signal once during loops. + /// + public bool emitOnce + { + get { return m_EmitOnce; } + set { m_EmitOnce = value; } + } + + /// + /// Asset representing the signal being emitted. + /// + public SignalAsset asset + { + get { return m_Asset; } + set { m_Asset = value; } + } + + PropertyName INotification.id + { + get + { + if (m_Asset != null) + { + return new PropertyName(m_Asset.name); + } + return new PropertyName(string.Empty); + } + } + + NotificationFlags INotificationOptionProvider.flags + { + get + { + return (retroactive ? NotificationFlags.Retroactive : default(NotificationFlags)) | + (emitOnce ? NotificationFlags.TriggerOnce : default(NotificationFlags)) | + NotificationFlags.TriggerInEditMode; + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalEmitter.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalEmitter.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..f14c8a341d952fb0c0f670e29d7151c70b8a1c3b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalEmitter.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 15c38f6fa1940124db1ab7f6fe7268d1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalReceiver.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalReceiver.cs new file mode 100644 index 0000000000000000000000000000000000000000..3752e8b2def843d6052ab7bffd9df0f0c0a2bdf2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalReceiver.cs @@ -0,0 +1,251 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Events; +using UnityEngine.Playables; + +namespace UnityEngine.Timeline +{ + /// + /// Listens for emitted signals and reacts depending on its defined reactions. + /// + /// A SignalReceiver contains a list of reactions. Each reaction is bound to a SignalAsset. + /// When a SignalEmitter emits a signal, the SignalReceiver invokes the corresponding reaction. + /// + /// + public class SignalReceiver : MonoBehaviour, INotificationReceiver + { + [SerializeField] + EventKeyValue m_Events = new EventKeyValue(); + + /// + /// Called when a notification is sent. + /// + /// The playable that sent the notification. + /// The received notification. Only notifications of type will be processed. + /// User defined data that depends on the type of notification. Uses this to pass necessary information that can change with each invocation. + public void OnNotify(Playable origin, INotification notification, object context) + { + var signal = notification as SignalEmitter; + if (signal != null && signal.asset != null) + { + UnityEvent evt; + if (m_Events.TryGetValue(signal.asset, out evt) && evt != null) + { + evt.Invoke(); + } + } + } + + /// + /// Defines a new reaction for a SignalAsset. + /// + /// The SignalAsset for which the reaction is being defined. + /// The UnityEvent that describes the reaction. + /// Thrown when the asset is null. + /// Thrown when the SignalAsset is already registered with this receiver. + public void AddReaction(SignalAsset asset, UnityEvent reaction) + { + if (asset == null) + throw new ArgumentNullException("asset"); + + if (m_Events.signals.Contains(asset)) + throw new ArgumentException("SignalAsset already used."); + m_Events.Append(asset, reaction); + } + + /// + /// Appends a null SignalAsset with a reaction specified by the UnityEvent. + /// + /// The new reaction to be appended. + /// The index of the appended reaction. + /// Multiple null assets are valid. + public int AddEmptyReaction(UnityEvent reaction) + { + m_Events.Append(null, reaction); + return m_Events.events.Count - 1; + } + + /// + /// Removes the first occurrence of a SignalAsset. + /// + /// The SignalAsset to be removed. + public void Remove(SignalAsset asset) + { + if (!m_Events.signals.Contains(asset)) + { + throw new ArgumentException("The SignalAsset is not registered with this receiver."); + } + + m_Events.Remove(asset); + } + + /// + /// Gets a list of all registered SignalAssets. + /// + /// Returns a list of SignalAssets. + public IEnumerable GetRegisteredSignals() + { + return m_Events.signals; + } + + /// + /// Gets the first UnityEvent associated with a SignalAsset. + /// + /// A SignalAsset defining the signal. + /// Returns the reaction associated with a SignalAsset. Returns null if the signal asset does not exist. + public UnityEvent GetReaction(SignalAsset key) + { + UnityEvent ret; + if (m_Events.TryGetValue(key, out ret)) + { + return ret; + } + + return null; + } + + /// + /// Returns the count of registered SignalAssets. + /// + /// + public int Count() + { + return m_Events.signals.Count; + } + + /// + /// Replaces the SignalAsset associated with a reaction at a specific index. + /// + /// The index of the reaction. + /// The replacement SignalAsset. + /// Thrown when the replacement SignalAsset is already registered to this SignalReceiver. + /// The new SignalAsset can be null. + public void ChangeSignalAtIndex(int idx, SignalAsset newKey) + { + if (idx < 0 || idx > m_Events.signals.Count - 1) + throw new IndexOutOfRangeException(); + + if (m_Events.signals[idx] == newKey) + return; + var alreadyUsed = m_Events.signals.Contains(newKey); + if (newKey == null || m_Events.signals[idx] == null || !alreadyUsed) + m_Events.signals[idx] = newKey; + + if (newKey != null && alreadyUsed) + throw new ArgumentException("SignalAsset already used."); + } + + /// + /// Removes the SignalAsset and reaction at a specific index. + /// + /// The index of the SignalAsset to be removed. + public void RemoveAtIndex(int idx) + { + if (idx < 0 || idx > m_Events.signals.Count - 1) + throw new IndexOutOfRangeException(); + m_Events.Remove(idx); + } + + /// + /// Replaces the reaction at a specific index with a new UnityEvent. + /// + /// The index of the reaction to be replaced. + /// The replacement reaction. + /// Thrown when the replacement reaction is null. + public void ChangeReactionAtIndex(int idx, UnityEvent reaction) + { + if (idx < 0 || idx > m_Events.events.Count - 1) + throw new IndexOutOfRangeException(); + + m_Events.events[idx] = reaction; + } + + /// + /// Gets the reaction at a specific index. + /// + /// The index of the reaction. + /// Returns a reaction. + public UnityEvent GetReactionAtIndex(int idx) + { + if (idx < 0 || idx > m_Events.events.Count - 1) + throw new IndexOutOfRangeException(); + return m_Events.events[idx]; + } + + /// + /// Gets the SignalAsset at a specific index + /// + /// The index of the SignalAsset. + /// Returns a SignalAsset. + public SignalAsset GetSignalAssetAtIndex(int idx) + { + if (idx < 0 || idx > m_Events.signals.Count - 1) + throw new IndexOutOfRangeException(); + return m_Events.signals[idx]; + } + + // Required by Unity for the MonoBehaviour to have an enabled state + private void OnEnable() + { + } + + [Serializable] + class EventKeyValue + { + [SerializeField] + List m_Signals = new List(); + + [SerializeField, CustomSignalEventDrawer] + List m_Events = new List(); + + public bool TryGetValue(SignalAsset key, out UnityEvent value) + { + var index = m_Signals.IndexOf(key); + if (index != -1) + { + value = m_Events[index]; + return true; + } + + value = null; + return false; + } + + public void Append(SignalAsset key, UnityEvent value) + { + m_Signals.Add(key); + m_Events.Add(value); + } + + public void Remove(int idx) + { + if (idx != -1) + { + m_Signals.RemoveAt(idx); + m_Events.RemoveAt(idx); + } + } + + public void Remove(SignalAsset key) + { + var idx = m_Signals.IndexOf(key); + if (idx != -1) + { + m_Signals.RemoveAt(idx); + m_Events.RemoveAt(idx); + } + } + + public List signals + { + get { return m_Signals; } + } + + public List events + { + get { return m_Events; } + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalReceiver.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalReceiver.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..8d08ff6b3530d2886c263cdfb8b469fc207cff70 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Events/Signals/SignalReceiver.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e52de21a22b6dd44c9cc19f810c65059 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Utilities/WeightUtility.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Utilities/WeightUtility.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..bf2c55d79233daff2977b844105fd7db6012f37a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Runtime/Utilities/WeightUtility.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e7a505b341283e14696e86433a5b1ae9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/iGeo/FWE-1B_QUESTION_2018iGeo.pdf b/benchmark/iGeo/FWE-1B_QUESTION_2018iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..74c043027b29dce929501df849af7c01fb987d02 --- /dev/null +++ b/benchmark/iGeo/FWE-1B_QUESTION_2018iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:776e8fd00997feed60c957bc120b1d47ef720c3caa309e3a4b3f2a8065f2220d +size 2212975 diff --git a/benchmark/iGeo/FWE-1_Student-booklet_2024iGeo.pdf b/benchmark/iGeo/FWE-1_Student-booklet_2024iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..4f510118642cdc9593c15babc8fea5720bda9941 --- /dev/null +++ b/benchmark/iGeo/FWE-1_Student-booklet_2024iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9d5434753b72a0a81777821540276c605500b3370bd7260629d48d9e373231a7 +size 221079 diff --git a/benchmark/iGeo/FWE-2_Map-C2_2018iGeo.pdf b/benchmark/iGeo/FWE-2_Map-C2_2018iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..438e5c8d72cab97690f28eff13a153bce53b8b40 --- /dev/null +++ b/benchmark/iGeo/FWE-2_Map-C2_2018iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cc486961728f4fa2441fa19edbef1509bb5f538e16db7a474e0f2434831f519c +size 525941 diff --git a/benchmark/iGeo/FWE-2_QUESTION_2018iGeo.pdf b/benchmark/iGeo/FWE-2_QUESTION_2018iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..1e98cc188d3ed12528464d0a031e5b95268330dd --- /dev/null +++ b/benchmark/iGeo/FWE-2_QUESTION_2018iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cf3e9e85a2796e8143aa976495372e109d0249d015c2157196c83ee7d7a07ba6 +size 181284 diff --git a/benchmark/iGeo/FWE-2_Student-booklet_2024iGeo.pdf b/benchmark/iGeo/FWE-2_Student-booklet_2024iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..ca8fbff345a3c8389ede39a00c1a974a29bb216e --- /dev/null +++ b/benchmark/iGeo/FWE-2_Student-booklet_2024iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:73fc203b3da3d97dda33fb1975ca6e0c8df9a895455280f942ad8d0ea30f3dd2 +size 358104 diff --git a/benchmark/iGeo/FWE_Briefing-v1_2019iGeo.pdf b/benchmark/iGeo/FWE_Briefing-v1_2019iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..9f2e1fc1c8ee8e22f582df24f9c976da24e9a231 --- /dev/null +++ b/benchmark/iGeo/FWE_Briefing-v1_2019iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:254590cccce4016caccc1f8e3699142305665e7b436d8452319a823a6dc21723 +size 8817689 diff --git a/benchmark/iGeo/FWE_Information-Booklet_2024iGeo.pdf b/benchmark/iGeo/FWE_Information-Booklet_2024iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..abfa2394e5a7cc7fbd29a843857828e7a6c9b583 --- /dev/null +++ b/benchmark/iGeo/FWE_Information-Booklet_2024iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:edba36ea97e32accd9f6dabbe4d829d6e43299117ba7d6a0f49b131e3b9b9602 +size 437413 diff --git a/benchmark/iGeo/FWE_Instructions_2019iGeo.pdf b/benchmark/iGeo/FWE_Instructions_2019iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..204f83894313b39fa3abe4fe18583f614b2d537a --- /dev/null +++ b/benchmark/iGeo/FWE_Instructions_2019iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9d96b2c38cc63d4a516badfb96697b4e990520adb3266b27b1326f3042b1dc71 +size 242546 diff --git a/benchmark/iGeo/FWE_Mark-Scheme_2024iGeo.pdf b/benchmark/iGeo/FWE_Mark-Scheme_2024iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..ec777770fab4798ed9c92c435cbee74c4c39cbc8 --- /dev/null +++ b/benchmark/iGeo/FWE_Mark-Scheme_2024iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2de3495760eccae9d25cdfe160b31a1135476472fcd7b6c93cb7a9b0dd46ddd4 +size 240835 diff --git a/benchmark/iGeo/FWE_Task1_QP_2019iGeo.pdf b/benchmark/iGeo/FWE_Task1_QP_2019iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..217251225e70160568add5c684188d5df03dc8ab --- /dev/null +++ b/benchmark/iGeo/FWE_Task1_QP_2019iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ce6ad1dc2b28ad1b48088c79c9230dcb6a6aa40056705d558b7a98364f59e9be +size 2013780 diff --git a/benchmark/iGeo/FWE_Task2_QP_2019iGeo.pdf b/benchmark/iGeo/FWE_Task2_QP_2019iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..f1327900071b4d272d1984e067f727a5e94f17a2 --- /dev/null +++ b/benchmark/iGeo/FWE_Task2_QP_2019iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0ad349be5ea304d55865a35f382cecaf4ca36a7fa3f4c981d5fe0b2b3c28adb4 +size 1195261 diff --git a/benchmark/iGeo/FWE_Task_maps_2019iGeo_20190722.pdf b/benchmark/iGeo/FWE_Task_maps_2019iGeo_20190722.pdf new file mode 100644 index 0000000000000000000000000000000000000000..96856abe7cb4f4e5b030b6a8ba226f37597cfc2a --- /dev/null +++ b/benchmark/iGeo/FWE_Task_maps_2019iGeo_20190722.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d36a6d5e027df5f85cc14623dc5a2f098e65b4180d850de9af7f5d82a7bd7502 +size 656362 diff --git a/benchmark/iGeo/FWE_Test_QP_2019iGeo.pdf b/benchmark/iGeo/FWE_Test_QP_2019iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..5a76bcd28fc8ae97fb10c92617162b97cd0e24d4 --- /dev/null +++ b/benchmark/iGeo/FWE_Test_QP_2019iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aba2538b318d23bf557b2244cc1506b971f92360551f6e3ec92de1741d0d668f +size 2168313 diff --git a/benchmark/iGeo/MMT-Sample-Questions.pdf b/benchmark/iGeo/MMT-Sample-Questions.pdf new file mode 100644 index 0000000000000000000000000000000000000000..d27449e680acdeb136a0b7d383ec76cb6638ed4e --- /dev/null +++ b/benchmark/iGeo/MMT-Sample-Questions.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bcdfd8805dd7f5ad13040c1f68080f05b4474cd3b4d832a3ff2141a3183d88ff +size 5484290 diff --git a/benchmark/iGeo/WRT-2022-Question-and-Resource-Booklet.pdf b/benchmark/iGeo/WRT-2022-Question-and-Resource-Booklet.pdf new file mode 100644 index 0000000000000000000000000000000000000000..de8d3594ec7f49b5b6f591b7765453228f93fac4 --- /dev/null +++ b/benchmark/iGeo/WRT-2022-Question-and-Resource-Booklet.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:00b4fe0bf773cbd524f625461e83df3bf4601b1d05cd3034ebf59e8ac25b175d +size 2878686 diff --git a/benchmark/iGeo/WRT-2024-Question-and-Answer-Booklet.pdf b/benchmark/iGeo/WRT-2024-Question-and-Answer-Booklet.pdf new file mode 100644 index 0000000000000000000000000000000000000000..ccac7a659213f47e3b9e36db24b6136bb574ca20 --- /dev/null +++ b/benchmark/iGeo/WRT-2024-Question-and-Answer-Booklet.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0e97b1c29b2f952c62f8a232745bf136738a95d4dc6d01c02a181d1a81e27e1d +size 191452 diff --git a/benchmark/iGeo/WRT_Marking-Scheme_2018iGeo_final_version.pdf b/benchmark/iGeo/WRT_Marking-Scheme_2018iGeo_final_version.pdf new file mode 100644 index 0000000000000000000000000000000000000000..7d18f4e96c64d65f9440ec0bae24bb5b4aaa689f --- /dev/null +++ b/benchmark/iGeo/WRT_Marking-Scheme_2018iGeo_final_version.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ebf15ebc439d73aa855ad474927c072cbdfccdfe56fe4b0c330ad2cbeab88a09 +size 1413328 diff --git a/benchmark/iGeo/WRT_Marking-Scheme_2024iGeo.pdf b/benchmark/iGeo/WRT_Marking-Scheme_2024iGeo.pdf new file mode 100644 index 0000000000000000000000000000000000000000..7ac305c41a6716854819e00585efb2f131b141c3 --- /dev/null +++ b/benchmark/iGeo/WRT_Marking-Scheme_2024iGeo.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a01663f58a5de2d296dd144823837eefb948d27b8cfa470b22f4691e2135d6e +size 694622 diff --git a/benchmark/iGeo/WRT_Marking_Scheme_2019-iGeo_Hong-Kong.pdf b/benchmark/iGeo/WRT_Marking_Scheme_2019-iGeo_Hong-Kong.pdf new file mode 100644 index 0000000000000000000000000000000000000000..87e08a3293a8bcab1e6fab50f6b5bf4b67b30e44 --- /dev/null +++ b/benchmark/iGeo/WRT_Marking_Scheme_2019-iGeo_Hong-Kong.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e375219cd233498bdeff5161910dc4dd26c1404c32ab46070b170a946a393800 +size 639809 diff --git a/benchmark/iGeo/WRT_QA-Booklet_iGeo-2019.pdf b/benchmark/iGeo/WRT_QA-Booklet_iGeo-2019.pdf new file mode 100644 index 0000000000000000000000000000000000000000..835070b8f7ae335f8851ec637e2890ff77bcbdd0 --- /dev/null +++ b/benchmark/iGeo/WRT_QA-Booklet_iGeo-2019.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fe832c75d97c9fd8a515ecb715368ae307e2f44c630b7e407c903ab294275c96 +size 511302