public IEnumerator ShowFrameMarkers()
{
PlayableDirector director = EditorUtilityTest.NewSceneWithDirector();
TimelineClip clip = EditorUtilityTest.CreateTestSISTimelineClip(director);
StreamingImageSequencePlayableAsset sisAsset = clip.asset as StreamingImageSequencePlayableAsset;
Assert.IsNotNull(sisAsset);
yield return(null);
//Show
SISClipData clipData = sisAsset.GetBoundClipData();
TrackAsset trackAsset = clip.GetParentTrack();
clipData.RequestFrameMarkers(true, true);
TimelineEditor.Refresh(RefreshReason.ContentsModified);
yield return(null);
Assert.AreEqual(TimelineUtility.CalculateNumFrames(clip), trackAsset.GetMarkerCount());
yield return(null);
//Undo showing FrameMarkers
EditorUtilityTest.UndoAndRefreshTimelineEditor(); yield return(null);
Assert.False(clipData.AreFrameMarkersRequested());
Assert.AreEqual(0, trackAsset.GetMarkerCount());
EditorUtilityTest.DestroyTestTimelineAssets(clip);
yield return(null);
}
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 ResetFrameMarkers()
{
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);
yield return(null);
//Change image to false
StreamingImageSequenceTrack track = clip.GetParentTrack() as StreamingImageSequenceTrack;
Assert.IsNotNull(track);
foreach (var m in track.GetMarkers())
{
FrameMarker marker = m as FrameMarker;
Assert.IsNotNull(marker);
marker.SetFrameUsed(false);
UnityEngine.Assertions.Assert.IsFalse(marker.IsFrameUsed());
}
yield return(null);
sisAsset.ResetPlayableFrames();
yield return(null);
//Check if all markers have been reset to used
foreach (var m in track.GetMarkers())
{
FrameMarker marker = m as FrameMarker;
Assert.IsNotNull(marker);
UnityEngine.Assertions.Assert.IsTrue(marker.IsFrameUsed());
}
yield return(null);
EditorUtilityTest.DestroyTestTimelineAssets(clip);
yield return(null);
}
public IEnumerator SetPlayableAssetFPS()
{
PlayableDirector director = EditorUtilityTest.NewSceneWithDirector();
TimelineClip clip = EditorUtilityTest.CreateTestSISTimelineClip(director);
StreamingImageSequencePlayableAsset sisAsset = clip.asset as StreamingImageSequencePlayableAsset;
Assert.IsNotNull(sisAsset);
//Make sure that we have some images
int numImages = sisAsset.GetNumImages();
Assert.IsTrue(numImages > 0);
yield return(null);
//Set animationCurve with half speed
SISClipData sisClipData = sisAsset.GetBoundClipData();
Assert.IsNotNull(sisClipData);
float origCurveDuration = sisClipData.CalculateCurveDuration();
AnimationCurve halfSpeedCurve = AnimationCurve.Linear(0, 0, origCurveDuration * 2, 1.0f);
AnimationUtility.SetEditorCurve(clip.curves, StreamingImageSequencePlayableAsset.GetTimeCurveBinding(), halfSpeedCurve);
yield return(null);
float origFPS = SISPlayableAssetUtility.CalculateFPS(sisAsset);
float origDuration = (float)clip.duration;
float origTimeScale = (float)clip.timeScale;
SetFPSAndCheck(sisAsset, origFPS * 8.0f);
SetFPSAndCheck(sisAsset, origFPS / 16.0f);
SetFPSAndCheck(sisAsset, origFPS * 0.25f);
SetFPSAndCheck(sisAsset, origFPS * 4.0f);
SetFPSAndCheck(sisAsset, origFPS);
yield return(null);
//Check if we are back
Assert.IsTrue(Mathf.Approximately(origFPS, SISPlayableAssetUtility.CalculateFPS(sisAsset)));
Assert.IsTrue(Mathf.Approximately(origDuration, (float)clip.duration));
Assert.IsTrue(Mathf.Approximately(origTimeScale, (float)clip.timeScale));
EditorUtilityTest.DestroyTestTimelineAssets(clip);
yield return(null);
}
void SetFPSAndCheck(StreamingImageSequencePlayableAsset sisAsset, float newFPS)
{
SISClipData sisClipData = sisAsset.GetBoundClipData();
Assert.IsNotNull(sisClipData);
TimelineClip clip = sisClipData.GetOwner();
Assert.IsNotNull(clip);
float prevFPS = SISPlayableAssetUtility.CalculateFPS(sisAsset);
float prevClipDuration = (float)clip.duration;
float prevTimeScale = (float)clip.timeScale;
Assert.Greater(prevFPS, 0);
float fpsMultiplier = newFPS / prevFPS;
Assert.Greater(fpsMultiplier, 0);
float timeMultiplier = 1.0f / fpsMultiplier;
SISPlayableAssetUtility.SetFPS(sisAsset, newFPS);
Assert.IsTrue(Mathf.Approximately(prevClipDuration * timeMultiplier, (float)clip.duration));
Assert.IsTrue(Mathf.Approximately(prevTimeScale * fpsMultiplier, (float)clip.timeScale));
}
public IEnumerator UncheckFrameMarkers()
{
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);
yield return(null);
double timePerFrame = TimelineUtility.CalculateTimePerFrame(clip);
int numImages = sisAsset.GetNumImages();
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
EditorCurveBinding curveBinding = StreamingImageSequencePlayableAsset.GetTimeCurveBinding();
ExtendedClipEditorUtility.ResetClipDataCurve(sisAsset, curveBinding);
yield return(null);
sisAsset.ResetPlayableFrames();
yield return(null);
StreamingImageSequenceTrack track = clip.GetParentTrack() 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;
}
Assert.AreEqual(numImages, 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);
}
//---------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Import a timeline file exported from DCC tools into the scene in the Timeline object
/// </summary>
/// <param name="jsTimelinePath">The path of the file</param>
/// <param name="destFolder">The dest folder of the imported files</param>
public static void ImportTimeline(string jsTimelinePath, string destFolder = "")
{
// prepare asset name, paths, etc
string assetName = Path.GetFileNameWithoutExtension(jsTimelinePath);
string timelineFolder = Path.GetDirectoryName(jsTimelinePath);
if (string.IsNullOrEmpty(timelineFolder))
{
Debug.LogError("Can't get directory name for: " + jsTimelinePath);
return;
}
timelineFolder = Path.Combine(timelineFolder, destFolder, assetName).Replace("\\", "/");
//Check if we are exporting from external asset
if (!timelineFolder.StartsWith("Assets/"))
{
timelineFolder = Path.Combine("Assets", destFolder, assetName);
}
Directory.CreateDirectory(timelineFolder);
string strJson = File.ReadAllText(jsTimelinePath);
TimelineParam container = JsonUtility.FromJson <TimelineParam>(strJson);
string assetFolder = container.assetFolder;
if (string.IsNullOrEmpty(assetFolder))
{
assetFolder = Path.GetDirectoryName(jsTimelinePath);
}
//delete existing objects in the scene that is pointing to the Director
string timelinePath = Path.Combine(timelineFolder, assetName + "_Timeline.playable").Replace("\\", "/");
PlayableDirector director = RemovePlayableFromDirectorsInScene(timelinePath);
if (null == director)
{
GameObject directorGo = new GameObject(assetName);
director = directorGo.AddComponent <PlayableDirector>();
}
//Create timeline asset
TimelineAsset asset = ScriptableObject.CreateInstance <TimelineAsset>();
AssetEditorUtility.OverwriteAsset(asset, timelinePath);
director.playableAsset = asset;
string strHome = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
int numTracks = container.Tracks.Length;
for (int index = numTracks - 1; index >= 0; index--)
{
var track = container.Tracks[index];
string strFootagePath = track.Footage;
// remove '~' if necessary
if (strFootagePath.StartsWith("~"))
{
strFootagePath = strHome + strFootagePath.Substring(1);
}
if (!Path.IsPathRooted(strFootagePath))
{
strFootagePath = Path.Combine(assetFolder, strFootagePath);
}
string strFootageName = Path.GetFileNameWithoutExtension(strFootagePath);
string strJsonFootage = File.ReadAllText(strFootagePath);
AEFootageInfo footageInfo = JsonUtility.FromJson <AEFootageInfo>(strJsonFootage);
int numImages = footageInfo.Pictures.Count;
if (numImages > 0)
{
List <string> originalImagePaths = new List <string>(footageInfo.Pictures);
for (int xx = 0; xx < numImages; ++xx)
{
string fileName = footageInfo.Pictures[xx];
// replace '~' with the path to home (for Linux environment
if (fileName.StartsWith("~"))
{
fileName = strHome + fileName.Substring(1);
}
footageInfo.Pictures[xx] = Path.GetFileName(fileName);
}
string destFootageFolder = Application.streamingAssetsPath;
destFootageFolder = Path.Combine(destFootageFolder, strFootageName).Replace("\\", "/");
Directory.CreateDirectory(destFootageFolder); //make sure the directory exists
footageInfo.Folder = AssetUtility.NormalizeAssetPath(destFootageFolder);
for (int i = 0; i < numImages; ++i)
{
string destFilePath = Path.Combine(destFootageFolder, footageInfo.Pictures[i]);
if (File.Exists(destFilePath))
{
File.Delete(destFilePath);
}
string srcFilePath = Path.GetFullPath(Path.Combine(assetFolder, originalImagePaths[i])).Replace("\\", "/");
FileUtil.CopyFileOrDirectory(srcFilePath, destFilePath);
}
}
//Convert to WatchedFileInfo
List <WatchedFileInfo> imageFiles = WatchedFileInfo.CreateList(footageInfo.Folder, footageInfo.Pictures);
StreamingImageSequencePlayableAsset sisAsset = ScriptableObject.CreateInstance <StreamingImageSequencePlayableAsset>();
sisAsset.InitFolderInEditor(footageInfo.Folder, imageFiles, footageInfo.Resolution);
string playableAssetPath = Path.Combine(timelineFolder, strFootageName + "_StreamingImageSequence.playable");
AssetEditorUtility.OverwriteAsset(sisAsset, playableAssetPath);
StreamingImageSequenceTrack movieTrack = asset.CreateTrack <StreamingImageSequenceTrack>(null, strFootageName);
TimelineClip clip = movieTrack.CreateDefaultClip();
clip.asset = sisAsset;
clip.start = track.Start;
clip.duration = track.Duration;
clip.CreateCurves("Curves: " + clip.displayName);
SISClipData sisData = new SISClipData(clip);
sisAsset.BindClipData(sisData);
ExtendedClipEditorUtility.ResetClipDataCurve(sisAsset, StreamingImageSequencePlayableAsset.GetTimeCurveBinding());
if (Object.FindObjectOfType(typeof(UnityEngine.EventSystems.EventSystem)) == null)
{
var es = new GameObject();
es.AddComponent <UnityEngine.EventSystems.EventSystem>();
es.AddComponent <UnityEngine.EventSystems.StandaloneInputModule>();
es.name = "EventSystem";
}
GameObject canvasObj = null;
Canvas canvas = Object.FindObjectOfType(typeof(Canvas)) as Canvas;
if (canvas != null)
{
canvasObj = canvas.gameObject;
}
else
{
canvasObj = UIUtility.CreateCanvas().gameObject;
}
Transform directorT = director.gameObject.transform;
directorT.SetParent(canvasObj.transform);
directorT.localPosition = new Vector3(0.0f, 0.0f, 0.0f);
GameObject imageGo = null;
Transform imageT = directorT.Find(strFootageName);
if (null == imageT)
{
imageGo = new GameObject(strFootageName);
imageT = imageGo.transform;
}
else
{
imageGo = imageT.gameObject;
}
Image image = imageGo.GetOrAddComponent <Image>();
StreamingImageSequenceRenderer renderer = imageGo.GetOrAddComponent <StreamingImageSequenceRenderer>();
RectTransform rectTransform = imageGo.GetComponent <RectTransform>();
rectTransform.SetParent(directorT);
rectTransform.localPosition = new Vector3(0.0f, 0.0f, 0.0f);
rectTransform.sizeDelta = new Vector2(footageInfo.Resolution.Width,
footageInfo.Resolution.Height);
director.SetGenericBinding(movieTrack, renderer);
EditorUtility.SetDirty(director);
}
//cause crash if this is called inside of OnImportAsset()
UnityEditor.EditorApplication.delayCall += () => {
AssetDatabase.Refresh();
if (null != director)
{
Selection.activeGameObject = director.gameObject;
}
};
}
