io.atlasv.tools.timeline.core 0.2.0

package/Editor/AtlasV.Tools.Timeline.Core.Editor.asmdef

@@ -0,0 +1,20 @@
+{
+    "name": "AtlasV.Tools.Timeline.Core.Editor",
+    "rootNamespace": "",
+    "references": [
+        "GUID:370df0095b71ed0438fa74206900dee0",
+        "GUID:f06555f75b070af458a003d92f9efb00",
+        "GUID:02f771204943f4a40949438e873e3eff"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Editor/AtlasV.Tools.Timeline.Core.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: acc49ff4a3700f14aa3de4ee55a4f9b4
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Common/AutoNameClipEditor.cs

@@ -0,0 +1,24 @@
+using UnityEditor;
+using UnityEditor.Timeline;
+using UnityEngine.Timeline;
+
+namespace AtlasV.Tools.Timeline
+{
+    public class AutoNameClipEditor : ClipEditor
+    {
+        public override void OnClipChanged (TimelineClip clip)
+        {
+            IClipAutoName autoNameClip = clip.asset as IClipAutoName;
+
+            if ( autoNameClip == null )
+                return;
+
+            if ( string.IsNullOrEmpty (autoNameClip.autoName) )
+                return;
+
+            clip.displayName = autoNameClip.autoName;
+        }
+
+        
+    }
+}

package/Editor/Common/AutoNameClipEditor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 78dd83d81b25ead4986b1d1de63692d1

package/Editor/Common/InterpolateParamClipEditor.cs

@@ -0,0 +1,24 @@
+using System.Reflection;
+using UnityEngine.Timeline;
+
+namespace AtlasV.Tools.Timeline
+{
+    public class InterpolateParamClipEditor : AutoNameClipEditor
+    {
+
+        static FieldInfo preField =
+        typeof(TimelineClip).GetField("m_PreExtrapolationMode",
+            BindingFlags.Instance | BindingFlags.NonPublic);
+
+        static FieldInfo postField =
+        typeof(TimelineClip).GetField("m_PostExtrapolationMode",
+            BindingFlags.Instance | BindingFlags.NonPublic);
+
+        public override void OnCreate (TimelineClip clip, TrackAsset track, TimelineClip clonedFrom)
+        {
+            preField?.SetValue (clip, TimelineClip.ClipExtrapolation.Hold);
+            postField?.SetValue (clip, TimelineClip.ClipExtrapolation.Hold);
+        }
+
+    }
+}

package/Editor/Common/InterpolateParamClipEditor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 980d417020fc0bc41b1d22f60050b3e3

package/Editor/Common.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3cb798a2af12e734192d5ea1319202de
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/InterpolationParam/AInterpolateControlTrackWithSourceEditor.cs

@@ -0,0 +1,33 @@
+using UnityEditor;
+using UnityEditor.Timeline;
+using UnityEngine;
+
+namespace AtlasV.Tools.Timeline
+{
+    public abstract class AInterpolateControlTrackWithSourceEditor<TData, TPlayable> : Editor
+        where TData : UnityEngine.Object
+        where TPlayable : AInterpolatePlayableDataProvider<TData>, new()
+    {
+
+        SerializedProperty _cachedObject;
+
+        void OnEnable ()
+        {
+            _cachedObject = serializedObject.FindProperty ("_cachedObjects");
+        }
+
+        public override void OnInspectorGUI ()
+        {
+            base.OnInspectorGUI ();
+            var typedTarget = ( AInterpolateControlTrackWithSource<TData, TPlayable> ) target;
+            if ( typedTarget == null )
+                return;
+
+
+            GUI.enabled = false;
+            EditorGUILayout.IntField ("Num of animated Objects", typedTarget.count);
+            GUI.enabled = true;
+        }
+
+    }
+}

package/Editor/InterpolationParam/AInterpolateControlTrackWithSourceEditor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b253de484f768844b957ba69d853f980

package/Editor/InterpolationParam/GlobalShaderParamControlCilpEditors.cs

@@ -0,0 +1,35 @@
+using UnityEditor.Timeline;
+
+namespace AtlasV.Tools.Timeline
+{
+    [CustomTimelineEditor (typeof (GlobalShaderParamControlClipColor))]
+    public class GlobalShaderParamControlClipColorEditor : InterpolateParamClipEditor
+    {
+
+    }
+
+    [CustomTimelineEditor (typeof (GlobalShaderParamControlClipFloat))]
+    public class GlobalShaderParamControlClipFloatEditor : InterpolateParamClipEditor
+    {
+
+    }
+
+    [CustomTimelineEditor (typeof (GlobalShaderParamControlClipVector2))]
+    public class GlobalShaderParamControlClipVector2Editor : InterpolateParamClipEditor
+    {
+
+    }
+
+    [CustomTimelineEditor (typeof (GlobalShaderParamControlClipVector3))]
+    public class GlobalShaderParamControlClipVector3Editor : InterpolateParamClipEditor
+    {
+
+    }
+
+    [CustomTimelineEditor (typeof (GlobalShaderParamControlClipVector4))]
+    public class GlobalShaderParamControlClipVector4Editor : InterpolateParamClipEditor
+    {
+
+    }
+
+}

package/Editor/InterpolationParam/GlobalShaderParamControlCilpEditors.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 99f7eb22e355f9c41ae1941bd5117359

package/Editor/InterpolationParam/ShaderParamControlClipEditors.cs

@@ -0,0 +1,35 @@
+using UnityEditor.Timeline;
+
+namespace AtlasV.Tools.Timeline
+{
+    [CustomTimelineEditor (typeof (ShaderParamControlClipColor))]
+    public class ShaderParamControlClipColorEditor : InterpolateParamClipEditor
+    {
+    
+    }
+
+    [CustomTimelineEditor (typeof (ShaderParamControlClipFloat))]
+    public class ShaderParamControlClipFloatEditor : InterpolateParamClipEditor
+    {
+
+    }
+
+    [CustomTimelineEditor (typeof (ShaderParamControlClipVector2))]
+    public class ShaderParamControlClipVector2Editor : InterpolateParamClipEditor
+    {
+
+    }
+
+    [CustomTimelineEditor (typeof (ShaderParamControlClipVector3))]
+    public class ShaderParamControlClipVector3Editor : InterpolateParamClipEditor
+    {
+
+    }
+
+    [CustomTimelineEditor (typeof (ShaderParamControlClipVector4))]
+    public class ShaderParamControlClipVector4Editor : InterpolateParamClipEditor
+    {
+
+    }
+
+}

package/Editor/InterpolationParam/ShaderParamControlClipEditors.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: af2538902b8332346bae1b7a882c639d

package/Editor/InterpolationParam/ShaderParamControlTrackEditor.cs

@@ -0,0 +1,11 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace AtlasV.Tools.Timeline
+{
+    [CustomEditor (typeof (ShaderParamControlTrack))]
+    public class ShaderParamControlTrackEditor : AInterpolateControlTrackWithSourceEditor<Material, ShaderParamPlayable>
+    {
+
+    }
+}

package/Editor/InterpolationParam/ShaderParamControlTrackEditor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: c5c657b2b466c3540aba1bee48f3261b

package/Editor/InterpolationParam.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ab25e1f5cfe7fb04e8e35d7492a654c1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Tools/SelectAndLockTimeline.cs

@@ -0,0 +1,151 @@
+using UnityEditor.Toolbars;
+using UnityEditor;
+using UnityEngine;
+using UnityEditor.Timeline;
+using UnityEngine.Playables;
+using System.IO;
+using UnityEditor.SceneManagement;
+using UnityEngine.SceneManagement;
+
+
+public class SelectAndLockTimeline
+{
+    
+
+
+    const string kElementPath = "AtlasV/Select Timeline Dropdown";
+
+    static string[] timelinesName;
+
+    static PlayableDirector[] cachedTimelines = null;
+    static string currentSelection = "Not selected";
+    // static MainToolbarContent dropdownSelection = null;
+
+    [MainToolbarElement (kElementPath, defaultDockPosition = MainToolbarDockPosition.Middle)]
+    public static MainToolbarElement CreateSceneSelectorDropdown ()
+    {
+        currentSelection = "Not selected";
+
+        if ( Selection.activeObject is PlayableDirector director )
+        {
+            currentSelection = director.playableAsset.name;
+        }
+
+        var icon = EditorGUIUtility.IconContent("d_UnityEditor.Timeline.TimelineWindow").image as Texture2D;
+        var dropdownSelection = new MainToolbarContent(currentSelection, icon, "Select timeline");
+        return new MainToolbarDropdown (dropdownSelection, ShowDropdownMenu);
+    }
+
+    static void RefreshDirectorList ()
+    {
+        cachedTimelines = Object.FindObjectsByType<PlayableDirector> (FindObjectsInactive.Include, FindObjectsSortMode.None);
+
+        timelinesName = Directory.GetFiles ("Assets", "*.unity", SearchOption.AllDirectories);
+    }
+
+    static void ShowDropdownMenu (Rect dropDownRect)
+    {
+        var menu = new GenericMenu();
+        if ( timelinesName.Length == 0 )
+        {
+            menu.AddDisabledItem (new GUIContent ("No Scenes in Project"));
+        }
+        foreach ( PlayableDirector director in cachedTimelines )
+        {
+            string timelineName = director.playableAsset.name;
+            menu.AddItem (new GUIContent (timelineName), false, () =>
+            {
+                // dropdownSelection.text = timelineName;
+                currentSelection = timelineName;
+                SelectTimeline (director);
+                MainToolbar.Refresh (kElementPath);
+
+            });
+        }
+        menu.DropDown (dropDownRect);
+    }
+
+    static void SelectTimeline (PlayableDirector timeline)
+    {
+        if ( timeline != null )
+        {
+            Selection.activeObject = timeline;
+
+            OpenAndLockTimelineEditor (timeline);
+
+        }
+    }
+
+    static void SceneSwitched (Scene oldScene, Scene newScene)
+    {
+        MainToolbar.Refresh (kElementPath);
+    }
+
+    static SelectAndLockTimeline ()
+    {
+        RefreshDirectorList ();
+        EditorApplication.projectChanged += RefreshDirectorList;
+        SceneManager.activeSceneChanged += SceneSwitched;
+        EditorSceneManager.activeSceneChangedInEditMode += SceneSwitched;        
+    }
+
+
+    [MainToolbarElement ("AtlasV/Select Timeline Button", defaultDockPosition = MainToolbarDockPosition.Middle)]
+    public static MainToolbarElement SelectTimelineButton ()
+    {
+        var icon = EditorGUIUtility.IconContent("d_UnityEditor.Timeline.TimelineWindow").image as Texture2D;
+        var content = new MainToolbarContent(icon);
+        return new MainToolbarButton (content, SelectFirstTimeline);
+    }
+
+    static void SelectFirstTimeline ()
+    {
+        PlayableDirector timeline = null;
+        if ( Selection.activeObject is GameObject go )
+        {
+            timeline = go.GetComponent<PlayableDirector> ();
+
+            if ( timeline != null )
+            {
+                OpenAndLockTimelineEditor (timeline);
+                return;
+            }            
+        }
+
+
+        timeline = Object.FindFirstObjectByType<PlayableDirector> ();
+        if ( timeline != null )
+        {
+            Selection.activeObject = timeline;
+
+            OpenAndLockTimelineEditor (timeline);
+        }
+    }
+
+
+    static void OpenAndLockTimelineEditor (PlayableDirector timeline)
+    {
+
+        if ( timeline == null )
+            return;
+
+
+        if ( !EditorApplication.ExecuteMenuItem ("Window/Sequencing/Timeline") )
+        {
+            Debug.LogError ("Impossible d�ouvrir la Timeline (menu introuvable)");
+            return;
+        }
+
+        var timelineEditorWindow = TimelineEditor.GetWindow ();
+
+        if ( timelineEditorWindow != null )
+        {
+            // Find a Timeline component, then in case we are using Sequences, climb up to the root master sequence.
+            if ( timeline != null )
+            {
+                timelineEditorWindow.SetTimeline (timeline);
+                timelineEditorWindow.locked = true;
+            }
+        }
+    }
+}

package/Editor/Tools/SelectAndLockTimeline.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d9263a1f54077cc47bcb2c4496fd1f35

package/Editor/Tools.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 991cb5fb0655e5f4dbcfe61c74614df6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e433e20a950788143bee40e47b59fd66
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/AtlasV.Tools.Timeline.Core.Runtime.asmdef

@@ -0,0 +1,17 @@
+{
+    "name": "AtlasV.Tools.Timeline.Core.Runtime",
+    "rootNamespace": "",
+    "references": [
+        "GUID:f06555f75b070af458a003d92f9efb00",
+        "GUID:df380645f10b7bc4b97d4f5eb6303d95"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Runtime/AtlasV.Tools.Timeline.Core.Runtime.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 370df0095b71ed0438fa74206900dee0
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Common/AClipInfoTrack.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+
+namespace AtlasV.Tools.Timeline
+{
+    public abstract class AClipInfoTrack : TrackAsset
+    {
+
+        public override Playable CreateTrackMixer (PlayableGraph graph, GameObject go, int inputCount)
+        {
+
+            foreach ( var clip in GetClips () )
+            {
+                if ( clip.asset is AClipWithInfo controlClip )
+                {
+                    controlClip.clipInfo = new ClipInfo ()
+                    {
+                        start = clip.start,
+                        end = clip.end
+                    };
+                }
+
+            }
+
+            return base.CreateTrackMixer (graph, go, inputCount);
+        }
+    }
+}

package/Runtime/Common/AClipInfoTrack.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8512d6c9a2ee58d45a3618f91ecdd2aa

package/Runtime/Common/AClipWithInfo.cs

@@ -0,0 +1,9 @@
+using UnityEngine.Playables;
+
+namespace AtlasV.Tools.Timeline
+{
+    public abstract class AClipWithInfo : PlayableAsset
+    {
+        public ClipInfo clipInfo;
+    }
+}

package/Runtime/Common/AClipWithInfo.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 04c7570f97d0a7041a41bbf64b42ec40

package/Runtime/Common/AInterpolateControlClip.cs

@@ -0,0 +1,24 @@
+using UnityEngine;
+using UnityEngine.Playables;
+
+namespace AtlasV.Tools.Timeline
+{
+    public abstract class AInterpolateControlClip<TData, TPlayable, TInterpolator> : AClipWithInfo
+        where TPlayable : AInterpolatorPlayable<TData>, new()
+        where TInterpolator : ValueCurveInterpolator<TData>
+    {
+        public TInterpolator values;
+
+        public override Playable CreatePlayable (PlayableGraph graph, GameObject owner)
+        {
+            TPlayable behaviour = new TPlayable ()
+            {
+                clipInfo = clipInfo,
+                interpolator = values
+            };
+
+            Playable playable = ScriptPlayable <TPlayable>.Create ( graph, behaviour );
+            return playable;
+        }
+    }
+}

package/Runtime/Common/AInterpolateControlClip.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 64a1bbe1d1c24ac4489b31a544cf04bf

package/Runtime/Common/AInterpolatorPlayable.cs

@@ -0,0 +1,44 @@
+using System;
+using UnityEngine.Playables;
+
+namespace AtlasV.Tools.Timeline
+{
+
+
+    public abstract class AInterpolatePlayable : PlayableBehaviour
+    {
+        public ClipInfo clipInfo;
+
+        public override void ProcessFrame (Playable playable, FrameData info, object playerData)
+        {
+            if ( clipInfo == null )
+                return;
+
+            double time = playable.GetTime ( );
+            double ratio = time / clipInfo.duration;
+            float ratioF = (float) ratio;
+            RetrieveDataIfNeeded (playerData, info, playerData);
+            ApplyRatio (ratioF);
+        }
+
+        protected virtual void RetrieveDataIfNeeded (object playerData1, FrameData info, object playerData2)
+        {
+        }
+
+        protected abstract void ApplyRatio (float ratio);
+    }
+
+    public abstract class AInterpolatorPlayable<TData>: AInterpolatePlayable
+    {
+
+        public ValueCurveInterpolator<TData> interpolator;
+
+        protected override void ApplyRatio (float ratio)
+        {
+            TData value = interpolator.ApplyRatio (ratio);
+            Apply (value);
+        }
+
+        protected abstract void Apply (TData value);
+    }
+}

package/Runtime/Common/AInterpolatorPlayable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9417185561a55eb4dba92f9e553c475b

package/Runtime/Common/ATrackEnterExitBehaviour.cs

@@ -0,0 +1,54 @@
+using System;
+using UnityEngine.Playables;
+
+namespace AtlasV.Tools.Timeline
+{
+    public abstract class ATrackEnterExitBehaviour : PlayableBehaviour
+    {
+        public ClipInfo clipInfo;
+        protected bool _firstFrame = false;
+
+        protected abstract void OnEnterClip (Playable playable, object playerData);
+        protected abstract void OnExitClip (Playable playable);
+
+
+        private object _objectData;
+
+        public override void ProcessFrame (Playable playable, FrameData info, object playerData)
+        {
+            _objectData = playerData;
+            if ( _firstFrame == false )
+            {
+                _firstFrame = true;
+                OnEnterClip (playable, playerData);
+                // Debug.LogWarning (Time.frameCount + ") A::Enter Clip: " + _objectData);
+            }
+        }
+
+        // epsilon is used (and that large) because unity editor doesn't have very good precision when aligning clips together
+        private const double epsilon = 0.000000001d;
+
+        
+        public override void OnBehaviourPause (Playable playable, FrameData info)
+        {
+
+            double time = playable.GetTime ();
+            double duration = playable.GetDuration ();
+            double delta = Math.Abs (duration - time);
+            double globalTime = playable.GetGraph ( ).GetRootPlayable ( 0 ).GetTime ( );
+            bool outsideClip = globalTime < clipInfo.start || delta < epsilon;
+
+            if ( _firstFrame && outsideClip )
+            {
+                // Debug.LogWarning (Time.frameCount + ") A::Exit Clip: " + _objectData);
+                OnExitClip (playable);
+                _firstFrame = false;
+            }
+            /*else if (_firstFrame)
+            {
+                Debug.LogWarning (Time.frameCount + ") A::NOT EXITING Clip: " + _objectData + " -> " + time + "/" + clipInfo.start );
+            }*/
+        }
+
+    }
+}

package/Runtime/Common/ATrackEnterExitBehaviour.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5b8382bb49d23c147a380dc75b72a885

package/Runtime/Common/ClipInfo.cs

@@ -0,0 +1,8 @@
+namespace AtlasV.Tools.Timeline
+{
+    public class ClipInfo
+    {
+        public double start, end;
+        public double duration => end - start;
+    }
+}

package/Runtime/Common/ClipInfo.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 79928ade5eec1724eaa6cf8fb83b8bbf

package/Runtime/Common/IClipAutoName.cs

@@ -0,0 +1,10 @@
+namespace AtlasV.Tools.Timeline
+{
+    public interface IClipAutoName
+    {
+        public string autoName
+        {
+            get;
+        }
+    }
+}

package/Runtime/Common/IClipAutoName.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 23cff43584ee93c41932556b02f6cb4d