Exemplo n.º 1
0
        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);
        }
Exemplo n.º 2
0
        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));
        }
Exemplo n.º 3
0
//----------------------------------------------------------------------------------------------------------------------

    /// <summary>
    /// StreamingImageSequencePlayableAsset GUI Drawing
    /// </summary>
    public override void OnInspectorGUI() {
        if (null == m_asset)
            return;
        

        using (new EditorGUILayout.VerticalScope (GUI.skin.box))  {

            m_resolutionFoldout = EditorGUILayout.Foldout(m_resolutionFoldout, "Resolution");
            if (m_resolutionFoldout) {
                ImageDimensionInt res = m_asset.GetResolution();
                EditorGUILayout.LabelField("Width",  $"{res.Width } px");
                EditorGUILayout.LabelField("Height",  $"{res.Height } px");
            }
            GUILayout.Space(4f);
        }
        
        GUILayout.Space(4f);

        using (new EditorGUILayout.VerticalScope(GUI.skin.box))
        {
            GUILayout.Label("Folder", "BoldLabel");
            GUILayout.Space(4f);
            DrawFolderGUI();
        }
        GUILayout.Space(4f);

        using (new EditorGUILayout.VerticalScope(GUI.skin.box)) {
            int numImages = m_asset.GetNumImages();

            EditorGUILayout.BeginHorizontal();
            GUILayout.Label("Images: " + numImages, "BoldLabel");            
            if (GUILayout.Button("Reload", GUILayout.Width(50))) {
                m_asset.Reload();
            }
            EditorGUILayout.EndHorizontal();
            
            using (new EditorGUI.DisabledScope(0 == numImages)) {
                if (0 == numImages)
                    EditorGUILayout.IntField("FPS", 0);
                else {
                    TimelineClip clip = m_asset.GetBoundClipData()?.GetOwner();
                    //There is no assigned clip if the playableAsset is not loaded in TimelineWindow
                    if (null != clip) {                         
                                                
                        EditorGUIDrawerUtility.DrawUndoableGUI(clip.GetParentTrack(), "Change FPS", 
                            /*guiFunc=*/ ()=> {
                                float fps = SISPlayableAssetUtility.CalculateFPS(m_asset);
                                float val = EditorGUILayout.FloatField("FPS", fps); 
                                return Mathf.Max(0.1f, val);
                            }, 
                            /*updateFunc=*/ (float newFPS) => {
                                SISPlayableAssetUtility.SetFPS(m_asset, newFPS);                                
                            }
                        );
                    }                    
                }
            }
            
            GUILayout.Space(4f);
            m_imageListFoldout = EditorGUILayout.Foldout(m_imageListFoldout, "Images");
            if (m_imageListFoldout) {
                DoImageGUI();
            }
        }

        if (null == TimelineEditor.selectedClip) 
            return;
        
        GUILayout.Space(15);
        //Frame markers
        if (TimelineEditor.selectedClip.asset == m_asset) {
            using (new EditorGUILayout.HorizontalScope()) {
                InspectorUtility.DrawFrameMarkersGUI(m_asset);
                if (GUILayout.Button("Reset", GUILayout.Width(50f))) {
                    m_asset.ResetPlayableFrames();
                }
            }
        }
        GUILayout.Space(15);
        
        using (new EditorGUILayout.VerticalScope(GUI.skin.box)) {
            EditorGUILayout.LabelField("Background Colors");
            ++EditorGUI.indentLevel;
            
            EditorGUIDrawerUtility.DrawUndoableGUI(m_asset, "Change BG Color", 
                /*guiFunc=*/ ()=> EditorGUILayout.ColorField("In Timeline Window", m_asset.GetTimelineBGColor()), 
                /*updateFunc=*/ (Color newColor) => {                               
                    m_asset.SetTimelineBGColor(newColor);                                
                }
            );
            
            --EditorGUI.indentLevel;
            GUILayout.Space(15);
        }

        
        if (GUILayout.Button("Reset Curve (Not Undoable)")) {
            //AnimationUtility.SetEditorCurve(), which is called below, doesn't seem to be undoable
            EditorCurveBinding curveBinding = StreamingImageSequencePlayableAsset.GetTimeCurveBinding();                 
            ExtendedClipEditorUtility.ResetClipDataCurve(m_asset, curveBinding);
        }
    }