public DragAndDropVisualMode HandleGameObjectDrop(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
DragAndDropVisualMode result;
if (parentItem != null || targetItem != null)
{
result = 0;
}
else if (!DragAndDrop.get_objectReferences().Any((Object x) => x is GameObject))
{
result = 0;
}
else if (this.m_Window.state.currentDirector == null)
{
result = 32;
}
else
{
if (perform)
{
Object[] objectReferences = DragAndDrop.get_objectReferences();
for (int i = 0; i < objectReferences.Length; i++)
{
Object @object = objectReferences[i];
GameObject go = @object as GameObject;
if (!(go == null))
{
PrefabType prefabType = PrefabUtility.GetPrefabType(go);
if (prefabType != 1 && prefabType != 2)
{
IEnumerable <TrackType> enumerable = from x in TimelineHelpers.GetMixableTypes()
where x.requiresGameObjectBinding
select x;
GenericMenu genericMenu = new GenericMenu();
foreach (TrackType current in enumerable)
{
genericMenu.AddItem(new GUIContent(TimelineHelpers.GetTrackMenuName(current)), false, delegate(object e)
{
TrackAsset trackAsset = this.m_Window.AddTrack(((TrackType)e).trackType, null, string.Empty);
if (trackAsset.GetType() == typeof(ActivationTrack))
{
TimelineClip timelineClip = trackAsset.CreateClip(0.0);
timelineClip.displayName = ActivationTrackDrawer.Styles.ClipText.get_text();
}
this.m_Window.state.previewMode = false;
TimelineUtility.SetSceneGameObject(this.m_Window.state.currentDirector, trackAsset, go);
}, current);
}
genericMenu.ShowAsContext();
}
this.m_Window.state.Refresh();
}
}
}
result = 1;
}
return(result);
}
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));
}
}
protected override void UnloadTimelines()
{
base.UnloadTimelines();
TimelineUtility.UnloadTimelineResources(m_transition01);
TimelineUtility.UnloadTimelineResources(m_transition12);
TimelineUtility.UnloadTimelineResources(m_transition21);
TimelineUtility.UnloadTimelineResources(m_transition10);
TimelineUtility.UnloadTimelineResources(m_transition20);
TimelineUtility.UnloadTimelineResources(m_launchSpell);
}
public float EstimateControlWidth()
{
float estimatedTextSize = TimelineUtility.EstimateTextSize(m_Button);
float controlWidth = Math.Max(float.IsNaN(estimatedTextSize) ? layout.width : estimatedTextSize + 16, 80) + 2;
if (m_WarningIcon.style.display == DisplayStyle.Flex)
{
controlWidth += m_WarningIcon.layout.width;
}
return(controlWidth);
}
public IEnumerator ResizePlayableAsset()
{
PlayableDirector director = EditorUtilityTest.NewSceneWithDirector();
TimelineClip clip = EditorUtilityTest.CreateTestSISTimelineClip(director);
StreamingImageSequencePlayableAsset sisAsset = clip.asset as StreamingImageSequencePlayableAsset;
Assert.IsNotNull(sisAsset);
yield return(null);
SISClipData clipData = sisAsset.GetBoundClipData();
Assert.IsNotNull(clipData);
clipData.RequestFrameMarkers(true, true);
Undo.IncrementCurrentGroup(); //the base of undo is here. FrameMarkerVisibility is still true after undo
TimelineEditor.Refresh(RefreshReason.ContentsModified);
yield return(null);
//Original length
TrackAsset trackAsset = clip.GetParentTrack();
Assert.AreEqual(TimelineUtility.CalculateNumFrames(clip), trackAsset.GetMarkerCount());
double origClipDuration = clip.duration;
//Resize longer
EditorUtilityTest.ResizeSISTimelineClip(clip, origClipDuration + 3.0f); yield return(null);
Assert.AreEqual(TimelineUtility.CalculateNumFrames(clip), trackAsset.GetMarkerCount());
//Undo
EditorUtilityTest.UndoAndRefreshTimelineEditor(); yield return(null);
Assert.AreEqual(origClipDuration, clip.duration);
Assert.AreEqual(TimelineUtility.CalculateNumFrames(clip), trackAsset.GetMarkerCount());
//Resize shorter
EditorUtilityTest.ResizeSISTimelineClip(clip, Mathf.Max(0.1f, ((float)(origClipDuration) - 3.0f))); yield return(null);
Assert.AreEqual(TimelineUtility.CalculateNumFrames(clip), trackAsset.GetMarkerCount());
//Undo
EditorUtilityTest.UndoAndRefreshTimelineEditor(); yield return(null);
Assert.AreEqual(origClipDuration, clip.duration);
Assert.AreEqual(TimelineUtility.CalculateNumFrames(clip), trackAsset.GetMarkerCount());
EditorUtilityTest.DestroyTestTimelineAssets(clip);
yield return(null);
}
public IEnumerator DetectActiveClip()
{
PlayableDirector director = CreateDirectorWithTimelineAsset(TIMELINE_ASSET_PATH, out TimelineAsset timelineAsset);
TimelineEditorUtility.SelectDirectorInTimelineWindow(director); //trigger the TimelineWindow's update etc.
yield return(YieldEditorUtility.WaitForFramesAndIncrementUndo(1));
TrackAsset track = timelineAsset.CreateTrack <DummyTimelineTrack>(null, "FooTrack");
List <TimelineClip> clips = new List <TimelineClip>();
const int NUM_CLIPS = 3;
double nextClipStart = 0;
for (int i = 0; i < NUM_CLIPS; ++i)
{
TimelineClip curClip = TimelineEditorReflection.CreateClipOnTrack(typeof(DummyTimelinePlayableAsset), track, 0);
curClip.asset.name = $"Clip Asset {i}";
curClip.start = nextClipStart;
nextClipStart += curClip.duration;
clips.Add(curClip);
yield return(YieldEditorUtility.WaitForFramesAndIncrementUndo(1));
}
//Check that all clips have been created successfully
List <TimelineClip> trackClips = new List <TimelineClip>(track.GetClips());
HashSet <TimelineClip> trackClipsToCheck = new HashSet <TimelineClip>(trackClips);
for (int i = 0; i < NUM_CLIPS; ++i)
{
Assert.IsTrue(trackClipsToCheck.Contains(clips[i]));
trackClipsToCheck.Remove(clips[i]);
}
NUnit.Framework.Assert.Zero(trackClipsToCheck.Count);
yield return(YieldEditorUtility.WaitForFramesAndIncrementUndo(3));
//Ensure the active clip can be detected
for (int i = 0; i < NUM_CLIPS; ++i)
{
TimelineClip curClip = clips[i];
double time = curClip.start + curClip.duration * 0.5f;
TimelineUtility.GetActiveTimelineClipInto(trackClips, time, out TimelineClip detectedClip, out TimelineAsset _);
Assert.AreEqual(curClip, detectedClip);
}
yield return(YieldEditorUtility.WaitForFramesAndIncrementUndo(1));
TimelineEditorUtility.DestroyAssets(timelineAsset); //Cleanup
}
public async Task <IEnumerable <IHyperTagElement> > Timeline_Elements(
string id,
string realmId)
{
var filter = new TagItemFilterModel(id)
{
ServerUri = ServerUri,
RealmId = realmId
};
var utility = new TimelineUtility(_netStore);
var tag = await utility.GetTag(filter);
return(tag?.HyperTag.Elements.AsQueryable());
}
protected override IEnumerator LoadTimelines()
{
yield return(base.LoadTimelines());
yield return(TimelineUtility.LoadTimelineResources(m_transition01));
yield return(TimelineUtility.LoadTimelineResources(m_transition12));
yield return(TimelineUtility.LoadTimelineResources(m_transition21));
yield return(TimelineUtility.LoadTimelineResources(m_transition10));
yield return(TimelineUtility.LoadTimelineResources(m_transition20));
yield return(TimelineUtility.LoadTimelineResources(m_launchSpell));
}
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);
}
//----------------------------------------------------------------------------------------------------------------------
private void DrawUpdateRenderCacheGUI()
{
ShortcutBinding updateRenderCacheShortcut
= ShortcutManager.instance.GetShortcutBinding(SISEditorConstants.SHORTCUT_UPDATE_RENDER_CACHE);
using (new EditorGUILayout.VerticalScope(GUI.skin.box)) {
RenderCachePlayableAssetEditorConfig editorConfig = m_asset.GetEditorConfig();
bool captureAllFrames = EditorGUILayout.Toggle("Capture All Frames", editorConfig.GetCaptureAllFrames());
editorConfig.SetCaptureAllFrames(captureAllFrames);
EditorGUI.BeginDisabledGroup(captureAllFrames);
++EditorGUI.indentLevel;
int captureStartFrame = Math.Max(0, editorConfig.GetCaptureStartFrame());
int captureEndFrame = editorConfig.GetCaptureEndFrame();
if (captureEndFrame < 0)
{
captureEndFrame = TimelineUtility.CalculateNumFrames(TimelineEditor.selectedClip);
}
editorConfig.SetCaptureStartFrame(EditorGUILayout.IntField("From", captureStartFrame));
editorConfig.SetCaptureEndFrame(EditorGUILayout.IntField("To", captureEndFrame));
--EditorGUI.indentLevel;
EditorGUI.EndDisabledGroup();
GUILayout.Space(10);
if (GUILayout.Button($"Update Render Cache ({updateRenderCacheShortcut})"))
{
PlayableDirector director = TimelineEditor.inspectedDirector;
if (null == director)
{
EditorUtility.DisplayDialog("Streaming Image Sequence",
"PlayableAsset is not loaded in scene. Please load the correct scene before doing this operation.",
"Ok");
return;
}
//Loop time
EditorCoroutineUtility.StartCoroutine(UpdateRenderCacheCoroutine(director, m_asset), this);
}
}
}
public override void ProcessFrame(Playable playable, FrameData info, object playerData) {
TimelineUtility.GetActiveTimelineClipInto(m_clips, m_playableDirector.time, out TimelineClip clip,
out SceneCachePlayableAsset activePlayableAsset);
if (null == clip) {
UpdateObjectActiveStates();
return;
}
SceneCacheClipData clipData = activePlayableAsset.GetBoundClipData();
Assert.IsNotNull(clipData);
SceneCachePlayer scPlayer = activePlayableAsset.GetSceneCachePlayer();
if (null == scPlayer) {
UpdateObjectActiveStates();
return;
}
UpdateObjectActiveStates(activeObject: scPlayer.gameObject);
}
public async Task <TimelineViewModel> GetTimeline(
FilterViewModel filter)
{
if (!(!string.IsNullOrWhiteSpace(WorkflowInstanceId) ||
!string.IsNullOrWhiteSpace(AssetId)))
{
return(new TimelineViewModel());
}
var model = new TagPageFilterModel()
{
ServerUri = ServerUri,
PageSize = filter.PageSizeValue,
PageNumber = filter.PageNumber,
AssetIds = new List <string>()
{
AssetId
},
Start = filter.StartTime,
End = filter.EndTime,
GroupAndOrganize = true,
WorkflowInstanceId = WorkflowInstanceId,
MissionInstanceId = MissionInstanceId,
FilterValue = filter.Input,
//RealmId = realmId,
};
if (filter.FromSeconds.HasValue && filter.ToSeconds.HasValue)
{
model.Range = new TagPageFilterModel.PositionRange(filter.FromSeconds.Value, filter.ToSeconds.Value);
}
var utility = new TimelineUtility(_netStore);
return(await utility.GetTimeline(model));
}
public IEnumerator UncheckFrameMarkers()
{
PlayableDirector director = EditorUtilityTest.NewSceneWithDirector();
TimelineClip clip = EditorUtilityTest.CreateTestTimelineClip(director);
StreamingImageSequencePlayableAsset sisAsset = clip.asset as StreamingImageSequencePlayableAsset;
Assert.IsNotNull(sisAsset);
TimelineClipSISData timelineClipSISData = sisAsset.GetBoundTimelineClipSISData();
timelineClipSISData.RequestFrameMarkers(true);
yield return(null);
double timePerFrame = TimelineUtility.CalculateTimePerFrame(clip);
int numImages = sisAsset.GetImageFileNames().Count;
clip.timeScale = 3.75f; //use scaling
EditorUtilityTest.ResizeSISTimelineClip(clip, (timePerFrame * numImages));
yield return(null);
int numFrames = TimelineUtility.CalculateNumFrames(clip);
Assert.AreEqual(numImages, numFrames);
//Reset: make sure that the curve is a simple straight line from 0 to 1
StreamingImageSequencePlayableAsset.ResetTimelineClipCurve(clip);
yield return(null);
sisAsset.ResetPlayableFrames();
yield return(null);
StreamingImageSequenceTrack track = clip.parentTrack as StreamingImageSequenceTrack;
Assert.IsNotNull(track);
List <FrameMarker> frameMarkers = new List <FrameMarker>();
int i = 0;
foreach (var m in track.GetMarkers())
{
FrameMarker marker = m as FrameMarker;
Assert.IsNotNull(marker);
frameMarkers.Add(marker);
int imageIndex = sisAsset.GlobalTimeToImageIndex(clip, marker.time);
Assert.AreEqual(i, imageIndex);
++i;
}
//Uncheck and see if the unchecked images became ignored
frameMarkers[4].SetFrameUsed(false);
frameMarkers[5].SetFrameUsed(false);
Assert.AreEqual(3, sisAsset.GlobalTimeToImageIndex(clip, frameMarkers[4].time));
Assert.AreEqual(3, sisAsset.GlobalTimeToImageIndex(clip, frameMarkers[5].time));
frameMarkers[7].SetFrameUsed(false);
frameMarkers[8].SetFrameUsed(false);
Assert.AreEqual(6, sisAsset.GlobalTimeToImageIndex(clip, frameMarkers[7].time));
Assert.AreEqual(6, sisAsset.GlobalTimeToImageIndex(clip, frameMarkers[8].time));
EditorUtilityTest.DestroyTestTimelineAssets(clip);
yield return(null);
}
protected override IEnumerator LoadInternal()
{
yield return(TimelineUtility.LoadTimelineResources(m_timelineAsset));
m_initializationState = InitializationState.Loaded;
}
internal override bool IsEnabled()
{
return(TimelineUtility.IsCurrentSequenceValid() && !IsCurrentSequenceReadOnly() && base.IsEnabled());
}
protected override void UnloadInternal()
{
TimelineUtility.UnloadTimelineResources(m_timelineAsset);
m_initializationState = InitializationState.None;
}
public static void DrawNotations(
DrawInfo drawInfo,
int sampleRate = 60,
float tickmarkHeight = 32f,
bool above = false,
TimelineViewMode labelFormat = TimelineViewMode.seconds)
{
// first figure out what step I should use
float majorStepSize = 200.0f;
float width = drawInfo.layout.drawRect.width;
float height = drawInfo.layout.drawRect.height;
float numSteps = Mathf.Ceil(width / majorStepSize);
float scale = drawInfo.layout.Duration;
float scaleStep = scale / numSteps;
// Get the time step
float modScale = scaleStep;
float modScaleMult = 1.0f;
while (modScale < 1.0f)
{
modScale *= 10.0f;
modScaleMult *= 10.0f;
}
while (modScale > 10.0f)
{
modScale /= 10.0f;
modScaleMult /= 10.0f;
}
// modify scale to be divisible by 1/2/4/5
if (modScale > 5.0f)
{
modScale = 5.0f;
}
else if (modScale > 2.5f)
{
modScale = 2.5f;
}
else if (modScale > 2.0f)
{
modScale = 2.0f;
}
else
{
modScale = 1.0f;
}
modScale /= modScaleMult;
// with fixed scale need to find our start point
float startOffset = drawInfo.layout.startTime % modScale;
float start = drawInfo.layout.startTime - startOffset;
float rangeEnd = drawInfo.layout.startTime + scale;
float textLineHeight = GUI.skin.font.lineHeight;
float tickmarkHeightSmall = tickmarkHeight * 0.5f;
float tickmarkHeightMedium = tickmarkHeight * 0.75f;
float verticalPosition = above ? height : height - textLineHeight;
// draw
for (int i = -1;; ++i)
{
float point = start + modScale * i;
if (point > rangeEnd)
{
break;
}
// draw minor steps
for (int j = 1; j < 5; ++j)
{
float subPoint = point + (modScale / 5) * j;
float position = drawInfo.GetPixelPosition(subPoint);
float heightThis = (j == 2 ? tickmarkHeightSmall : tickmarkHeightMedium);
Rect r = new Rect(position, verticalPosition - heightThis, 1, heightThis);
GUI.color = k_MinorTickColor;
GUI.DrawTexture(r, EditorGUIUtility.whiteTexture);
}
// draw major step
{
float position = drawInfo.GetPixelPosition(point);
Rect r = new Rect(position, verticalPosition - tickmarkHeight, 1, tickmarkHeight);
GUI.color = k_MajorTickColor;
GUI.DrawTexture(r, EditorGUIUtility.whiteTexture);
string label = string.Empty;
int frame = (int)(point * sampleRate);
switch (labelFormat)
{
case TimelineViewMode.frames:
label = frame.ToString(CultureInfo.InvariantCulture);
break;
case TimelineViewMode.secondsFrames:
label = TimelineUtility.TimeToTimeFrameStr(point, sampleRate);
break;
default:
label = string.Format(scale < 0.1f ? "{0:0.000}" : "{0:0.00}", (float)point);
break;
}
var labelSize = GUI.skin.GetStyle("label").CalcSize(new GUIContent(label));
var labelOffset = labelSize.y - textLineHeight;
float x = position - labelSize.x * 0.5f;
float y;
if (above)
{
y = 0;
}
else
{
y = verticalPosition - labelOffset * 0.5f; // Centered position below guide line
}
var w = labelSize.x + 2;
var h = labelSize.y;
GUI.color = k_MajorTickColor;
GUI.Label(new Rect(x, y, w, h), label);
}
}
}
