opt: reduce the frequency of loading images in the Editor (#453)

Author: sindharta

Editor/Scripts/EditorManagers/EditorApplicationManager.cs

@@ -96,12 +96,19 @@ static void EditorApplicationManager_Update() {
         //Remove jobs
         foreach (IEditorTask job in m_toRemoveTasks) {
             m_activeEditorTasks.Remove(job);
-        }           
+            m_lastTaskExecuteTime.Remove(job);
+        }
         m_toRemoveTasks.Clear();
 
         //Execute
         foreach (IEditorTask job in m_activeEditorTasks) {
+            if (m_lastTaskExecuteTime.TryGetValue(job, out double lastExecuteTime)) {
+                if ((time - lastExecuteTime) <= job.GetExecutionFrequency())
+                    continue;
+            }
+            
             job.Execute();
+            m_lastTaskExecuteTime[job] = time;
         }
 
 
@@ -183,6 +190,9 @@ private static readonly ImageLoadEditorTask[] m_imageLoadEditorUpdateTasks
     private static readonly List<IEditorTask>    m_requestedTasks       = new List<IEditorTask>();
     private static readonly HashSet<IEditorTask> m_toRemoveTasks        = new HashSet<IEditorTask>();
 
+    private static readonly Dictionary<IEditorTask, double> m_lastTaskExecuteTime = new Dictionary<IEditorTask, double>();
+    
+    
     private static event Action<bool> OnUnityEditorFocus;
     private static bool               m_editorFocused;    
 

Editor/Scripts/EditorManagers/IEditorTask.cs

@@ -2,7 +2,8 @@
 {
 
 internal interface IEditorTask : ITask {
-    void Reset();
+    void  Reset();
+    float GetExecutionFrequency(); //once every xx in seconds
 }
 
 }

Editor/Scripts/EditorManagers/ImageLoadEditorTask.cs

@@ -11,6 +11,10 @@ public void Reset() {
         m_latestFrame = 0;        
     }
 
+    public float GetExecutionFrequency() {
+        return 0; //as soon as possible
+    }
+    
 //----------------------------------------------------------------------------------------------------------------------    
     public void Execute() {
 

Editor/Scripts/EditorManagers/SISPlayableMixerEditorTask.cs

@@ -18,6 +18,9 @@ public SISPlayableMixerEditorTask(StreamingImageSequencePlayableMixer mixer) : b
     public void Reset() {
     }
 
+    public float GetExecutionFrequency() {
+        return 1.0f / 10.0f;
+    }
 
 //----------------------------------------------------------------------------------------------------------------------    
 
@@ -67,7 +70,7 @@ public void Execute() {
         bool needsRefresh = false;
         foreach (KeyValuePair<TimelineClip, StreamingImageSequencePlayableAsset> kv in clipAssets) {
             StreamingImageSequencePlayableAsset sisAsset = kv.Value;
-            sisAsset.ContinuePreloadingImages();
+            sisAsset.ContinuePreloadingImages(numNeighboringImagesToLoad:1);
 
             if (sisAsset.UpdateTextureWithRequestedImage()) {
                 needsRefresh = true;

Runtime/Scripts/Features/SIS/StreamingImageSequencePlayableAsset.cs

@@ -294,18 +294,16 @@ internal bool UpdateTextureWithRequestedImage() {
 
 //----------------------------------------------------------------------------------------------------------------------
 
-    internal void ContinuePreloadingImages() {
+    internal void ContinuePreloadingImages(int numNeighboringImagesToLoad) {
 
         if (null == m_imageFiles || 0== m_imageFiles.Count)
             return;
 
         if (m_folder.IsRegularAssetPath())
             return;
 
-        const int NUM_IMAGES = 2;
-
         //forward
-        int maxForwardPreloadIndex = Mathf.Min(m_forwardPreloadImageIndex + NUM_IMAGES, m_imageFiles.Count) -1;
+        int maxForwardPreloadIndex   = Mathf.Min(m_forwardPreloadImageIndex + numNeighboringImagesToLoad, m_imageFiles.Count) -1;
         int startForwardPreloadIndex = m_forwardPreloadImageIndex;
         for (int i = startForwardPreloadIndex; i <= maxForwardPreloadIndex; ++i) {
             if (QueueImageLoadTask(i, out _)) {
@@ -316,7 +314,7 @@ internal void ContinuePreloadingImages() {
         }
 
         //backward
-        int minBackwardPreloadIndex = Mathf.Max((m_backwardPreloadImageIndex - NUM_IMAGES)+1, 0);
+        int minBackwardPreloadIndex   = Mathf.Max((m_backwardPreloadImageIndex - numNeighboringImagesToLoad)+1, 0);
         int startBackwardPreloadIndex = m_backwardPreloadImageIndex;
         for (int i = startBackwardPreloadIndex; i >=minBackwardPreloadIndex; --i) {
             if (QueueImageLoadTask(i, out _)) {

Runtime/Scripts/Features/SIS/StreamingImageSequencePlayableMixer.cs

@@ -96,7 +96,7 @@ public override void ProcessFrame(Playable playable, FrameData info, object play
 
             //Start to preload images before the clip is active
             if ( directorTime>= startTime - loadStartOffsetTime && directorTime < endTime) {
-                sisAsset.ContinuePreloadingImages();                    
+                sisAsset.ContinuePreloadingImages(numNeighboringImagesToLoad:1);
             }
 
         }