io.atlasv.tools.timeline.core 0.2.0

package/Runtime/Common/ValueCurveInterpolator.cs

@@ -0,0 +1,114 @@
+using System;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace AtlasV.Tools.Timeline
+{
+    public abstract class ValueCurveInterpolator<T>
+    {
+        
+        public AnimationCurve curve = AnimationCurve.Linear(0f, 0f, 1f, 1f);
+
+        public abstract T Lerp (float time);
+
+        public T ApplyRatio (float ratio)
+        {
+            float curveRatio = curve.Evaluate(ratio);
+            return Lerp (curveRatio);
+        }
+    }
+
+    [Serializable]
+    public class ColorCurveInterpolator : ValueCurveInterpolator<Color>
+    {
+        
+        public Color from;        
+        public Color to;
+
+        public override Color Lerp (float time)
+        {
+            return Color.Lerp (from, to, time);
+        }
+    }
+
+    [Serializable]
+    public class HDRColorCurveInterpolator : ValueCurveInterpolator<Color>
+    {
+        [ColorUsage (true, true)]
+        public Color from;
+        [ColorUsage (true, true)]
+        public Color to;
+
+        public override Color Lerp (float time)
+        {
+            return Color.Lerp (from, to, time);
+        }
+    }
+
+    [Serializable]
+    public class FloatCurveInterpolator : ValueCurveInterpolator<float>
+    {
+
+        public float from;
+        public float to;
+
+
+        public override float Lerp (float time)
+        {
+            return Mathf.Lerp (from, to, time);
+        }
+    }
+
+    [Serializable]
+    public class Vector2CurveInterpolator : ValueCurveInterpolator<Vector2>
+    {
+        public Vector2 from;
+        public Vector2 to;
+
+
+        public override Vector2 Lerp (float time)
+        {
+            return Vector2.Lerp (from, to, time);
+        }
+    }
+
+    [Serializable]
+    public class Vector3CurveInterpolator : ValueCurveInterpolator<Vector3>
+    {
+
+        public Vector3 from;
+        public Vector3 to;
+
+
+        public override Vector3 Lerp (float time)
+        {
+            return Vector3.Lerp (from, to, time);
+        }
+    }
+
+    [Serializable]
+    public class QuaternionCurveInterpolator : ValueCurveInterpolator<Quaternion>
+    {
+
+        public Quaternion from;
+        public Quaternion to;
+
+
+        public override Quaternion Lerp (float time)
+        {
+            return Quaternion.Slerp (from, to, time);
+        }
+    }
+
+    [Serializable]
+    public class Vector4CurveInterpolator : ValueCurveInterpolator<Vector4>
+    {
+        public Vector4 from;
+        public Vector4 to;
+
+        public override Vector4 Lerp (float time)
+        {
+            return Vector4.Lerp (from, to, time);
+        }
+    }
+}

package/Runtime/Common/ValueCurveInterpolator.cs.meta

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

package/Runtime/Common.meta

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

package/Runtime/GlobalShader/AGlobalShaderParamClip.cs

@@ -0,0 +1,75 @@
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+
+namespace AtlasV.Tools.Timeline
+{
+
+
+    public abstract class AGlobalShaderParamClip: PlayableAsset, IClipAutoName, ITimelineClipAsset
+    {
+
+        public string paramName;
+
+        protected int _parameterId = -1;
+
+        protected bool parameterValid => _parameterId != -1;
+
+        
+
+        protected void OnParameterChanged ()
+        {
+            if ( string.IsNullOrEmpty (paramName) == false )
+            {
+                _parameterId = Shader.PropertyToID (paramName);
+            }
+        }
+
+
+        public void CheckParamName ()
+        {
+
+            if ( string.IsNullOrEmpty (paramName) )
+            {
+                _parameterId = -1;
+            }
+            else if ( parameterValid == false )
+            {
+                _parameterId = Shader.PropertyToID (paramName);
+            }
+
+        }
+
+        public string autoName => paramName;
+
+        public ClipInfo clipInfo;
+
+        public ClipCaps clipCaps
+        {
+            get
+            {
+                return ClipCaps.ClipIn | ClipCaps.Extrapolation | ClipCaps.Looping | ClipCaps.SpeedMultiplier;
+            }
+        }
+
+        public override Playable CreatePlayable (PlayableGraph graph, GameObject owner)
+        {
+            GlobalShaderParamPlayable behaviour = new GlobalShaderParamPlayable ()
+            {
+                interpolator = this,
+                clipInfo = clipInfo,
+            };
+
+            Playable playable = ScriptPlayable <GlobalShaderParamPlayable>.Create ( graph, behaviour );
+            return playable;
+        }
+
+        public abstract void Apply (float ratio);
+    }
+
+    public abstract class AGlobalShaderParamClip<TInterpolator> : AGlobalShaderParamClip
+    {
+        public TInterpolator values;
+    }
+
+}

package/Runtime/GlobalShader/AGlobalShaderParamClip.cs.meta

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

package/Runtime/GlobalShader/GlobalShaderParamControlClipColor.cs

@@ -0,0 +1,16 @@
+using UnityEngine;
+
+namespace AtlasV.Tools.Timeline
+{
+    public class GlobalShaderParamControlClipColor : AGlobalShaderParamClip<ColorCurveInterpolator>
+    {
+        public override void Apply (float ratio)
+        {
+            CheckParamName ();
+
+            Color color = values.ApplyRatio (ratio);
+            Shader.SetGlobalColor (_parameterId, color);
+        }
+    }
+
+}

package/Runtime/GlobalShader/GlobalShaderParamControlClipColor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7e00ef9144e87ff488eba8697d2be0a8

package/Runtime/GlobalShader/GlobalShaderParamControlClipFloat.cs

@@ -0,0 +1,18 @@
+using UnityEngine;
+
+namespace AtlasV.Tools.Timeline
+{
+    public class GlobalShaderParamControlClipFloat : AGlobalShaderParamClip<FloatCurveInterpolator>
+    {
+        public override void Apply (float ratio)
+        {
+
+            CheckParamName ();
+
+            float value = values.ApplyRatio (ratio);
+            Shader.SetGlobalFloat (_parameterId, value);
+        }
+
+    }
+
+}

package/Runtime/GlobalShader/GlobalShaderParamControlClipFloat.cs.meta

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

package/Runtime/GlobalShader/GlobalShaderParamControlClipHDRColor.cs

@@ -0,0 +1,17 @@
+using UnityEngine;
+
+namespace AtlasV.Tools.Timeline
+{
+
+    public class GlobalShaderParamControlClipHDRColor : AGlobalShaderParamClip<HDRColorCurveInterpolator>
+    {
+        public override void Apply (float ratio)
+        {
+            CheckParamName ();
+
+            Color color = values.ApplyRatio (ratio);
+            Shader.SetGlobalColor (_parameterId, color);
+        }
+    }
+
+}

package/Runtime/GlobalShader/GlobalShaderParamControlClipHDRColor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 56c11e01a7801944385a5cacdc4108e3

package/Runtime/GlobalShader/GlobalShaderParamControlClipVector2.cs

@@ -0,0 +1,17 @@
+using UnityEngine;
+
+namespace AtlasV.Tools.Timeline
+{
+    public class GlobalShaderParamControlClipVector2 : AGlobalShaderParamClip<Vector2CurveInterpolator>
+    {
+        public override void Apply (float ratio)
+        {
+            CheckParamName ();
+
+            var value = values.ApplyRatio (ratio);
+            Shader.SetGlobalVector (_parameterId, value);
+        }
+
+    }
+
+}

package/Runtime/GlobalShader/GlobalShaderParamControlClipVector2.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 19152b82336a4fb48bb11d37e553ecd2

package/Runtime/GlobalShader/GlobalShaderParamControlClipVector3.cs

@@ -0,0 +1,17 @@
+using UnityEngine;
+
+namespace AtlasV.Tools.Timeline
+{
+    public class GlobalShaderParamControlClipVector3 : AGlobalShaderParamClip<Vector3CurveInterpolator>
+    {
+        public override void Apply (float ratio)
+        {
+            CheckParamName ();
+
+            var value = values.ApplyRatio (ratio);
+            Shader.SetGlobalVector (_parameterId, value);
+        }
+
+    }
+
+}

package/Runtime/GlobalShader/GlobalShaderParamControlClipVector3.cs.meta

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

package/Runtime/GlobalShader/GlobalShaderParamControlClipVector4.cs

@@ -0,0 +1,18 @@
+using UnityEngine;
+
+namespace AtlasV.Tools.Timeline
+{
+
+    public class GlobalShaderParamControlClipVector4 : AGlobalShaderParamClip<Vector4CurveInterpolator>
+    {
+        public override void Apply (float ratio)
+        {
+            CheckParamName ();
+
+            var value = values.ApplyRatio (ratio);
+            Shader.SetGlobalVector (_parameterId, value);
+        }
+
+    }
+
+}

package/Runtime/GlobalShader/GlobalShaderParamControlClipVector4.cs.meta

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

package/Runtime/GlobalShader/GlobalShaderParamPlayable.cs

@@ -0,0 +1,24 @@
+using UnityEngine.Playables;
+
+namespace AtlasV.Tools.Timeline
+{
+
+    public class GlobalShaderParamPlayable : PlayableBehaviour
+    {
+        public AGlobalShaderParamClip interpolator;
+        public ClipInfo clipInfo;
+
+        public override void ProcessFrame (Playable playable, FrameData info, object playerData)
+        {
+
+            if ( interpolator == null || clipInfo == null )
+                return;
+
+            double time = playable.GetTime ( );
+            double ratio = time / clipInfo.duration;
+            float ratioF = (float) ratio;
+
+            interpolator.Apply (ratioF);
+        }
+    }
+}

package/Runtime/GlobalShader/GlobalShaderParamPlayable.cs.meta

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

package/Runtime/GlobalShader/GlobalShaderParamTrack.cs

@@ -0,0 +1,35 @@
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+
+namespace AtlasV.Tools.Timeline
+{
+    [TrackColor (0f, 0.9811321f, 0.8742357f)]
+    [TrackClipType (typeof (GlobalShaderParamControlClipFloat))]
+    [TrackClipType (typeof (GlobalShaderParamControlClipColor))]
+    [TrackClipType (typeof (GlobalShaderParamControlClipHDRColor))]
+    [TrackClipType (typeof (GlobalShaderParamControlClipVector2))]
+    [TrackClipType (typeof (GlobalShaderParamControlClipVector3))]
+    [TrackClipType (typeof (GlobalShaderParamControlClipVector4))]
+    public class GlobalShaderParamTrack : TrackAsset
+    {
+        public override Playable CreateTrackMixer (PlayableGraph graph, GameObject go, int inputCount)
+        {
+
+            foreach ( var clip in GetClips () )
+            {
+                if ( clip.asset is AGlobalShaderParamClip controlClip )
+                {
+                    controlClip.clipInfo = new ClipInfo ()
+                    {
+                        start = clip.start,
+                        end = clip.end
+                    };
+                }
+
+            }
+
+            return base.CreateTrackMixer (graph, go, inputCount);
+        }
+    }
+}

package/Runtime/GlobalShader/GlobalShaderParamTrack.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 95f9a8dfcbc41b24f98db09bbaad3ab0

package/Runtime/GlobalShader.meta

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

package/Runtime/InterpolationParam/AInterpolateControlClipDataProvider.cs

@@ -0,0 +1,34 @@
+using UnityEngine;
+using UnityEngine.Playables;
+
+namespace AtlasV.Tools.Timeline
+{
+
+
+    public interface IRuntimeInterpolator<TData> where TData : UnityEngine.Object
+    {
+        public void Apply (TData data, float ratio);
+    }
+
+    public abstract class AInterpolateControlClipDataProvider<TData, TPlayable> : AClipWithInfo, IRuntimeInterpolator<TData>
+        where TData : UnityEngine.Object
+        where TPlayable: AInterpolatePlayableDataProvider<TData>, new()
+    {
+        public ITimelineDataProvider<TData> dataHolder;
+
+        public override Playable CreatePlayable (PlayableGraph graph, GameObject owner)
+        {
+            TPlayable behaviour = new TPlayable ()
+            {
+                interpolator = this,
+                clipInfo = clipInfo,
+                dataHolder = dataHolder
+            };
+
+            Playable playable = ScriptPlayable <TPlayable>.Create ( graph, behaviour );
+            return playable;
+        }
+
+        public abstract void Apply (TData data, float ratio);
+    }
+}

package/Runtime/InterpolationParam/AInterpolateControlClipDataProvider.cs.meta

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

package/Runtime/InterpolationParam/AInterpolateControlTrackDataProvider.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+
+namespace AtlasV.Tools.Timeline
+{
+
+    public interface ITimelineDataProvider<T> where T : Object
+    {
+        public List<T> GetTrackedObject (Object userData);
+    }
+
+    public abstract class AInterpolateControlTrackDataProvider<TData, TPlayable> : TrackAsset, ITimelineDataProvider<TData>
+        where TData : UnityEngine.Object
+        where TPlayable : AInterpolatePlayableDataProvider<TData>, new()
+    {
+        public abstract List<TData> GetTrackedObject (Object userData);
+
+        public override Playable CreateTrackMixer (PlayableGraph graph, GameObject go, int inputCount)
+        {
+
+            foreach ( var clip in GetClips () )
+            {
+                if ( clip.asset is AInterpolateControlClipDataProvider<TData, TPlayable> controlClip )
+                {
+                    controlClip.clipInfo = new ClipInfo ()
+                    {
+                        start = clip.start,
+                        end = clip.end
+                    };
+                    controlClip.dataHolder = this;
+                }
+
+            }
+
+            return base.CreateTrackMixer (graph, go, inputCount);
+        }
+    }
+}

package/Runtime/InterpolationParam/AInterpolateControlTrackDataProvider.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 55e19101ba302c24bbb510995690dacc

package/Runtime/InterpolationParam/AInterpolateControlTrackWithSource.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace AtlasV.Tools.Timeline
+{
+    public abstract class AInterpolateControlTrackWithSource<TData, TPlayable> : AInterpolateControlTrackDataProvider<TData, TPlayable>
+        where TData : UnityEngine.Object
+        where TPlayable : AInterpolatePlayableDataProvider<TData>, new()
+    {
+
+        protected List<TData> _toApply;
+        protected GameObject _source;
+        protected bool _appRunning = false;
+
+        public int count => _toApply != null ? _toApply.Count : 0;
+
+
+        public override List<TData> GetTrackedObject (Object userData)
+        {
+            var go = userData as GameObject;
+
+            if ( _toApply != null && _toApply.Count > 0 && _source == go && _appRunning == Application.isPlaying )
+            {
+                _toApply.RemoveAll (m => m == null);
+
+                if ( _toApply.Count > 0 )
+                    return _toApply;
+            }
+            if ( go == null )
+            {
+                return null;
+            }
+            _appRunning = Application.isPlaying;
+            _source = go;
+
+            _toApply = GatherData (_source);
+            return _toApply;
+        }
+
+        protected abstract List<TData> GatherData (GameObject source);
+    }
+}

package/Runtime/InterpolationParam/AInterpolateControlTrackWithSource.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 910ab8c6f6c66e046ab8740cb78a6e56

package/Runtime/InterpolationParam/AInterpolatePlayableDataProvider.cs

@@ -0,0 +1,39 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Playables;
+
+namespace AtlasV.Tools.Timeline
+{    
+
+    public abstract class AInterpolatePlayableDataProvider<TData> : PlayableBehaviour
+        where TData: Object
+    {
+        public IRuntimeInterpolator<TData> interpolator;
+        public ITimelineDataProvider<TData> dataHolder;
+        public ClipInfo clipInfo;
+        
+
+        public override void ProcessFrame (Playable playable, FrameData info, object playerData)
+        {
+
+            if ( dataHolder == null || interpolator == null || clipInfo == null)
+                return;
+
+            List<TData> toApply = dataHolder.GetTrackedObject (info.output.GetUserData ());
+
+            if ( toApply == null )
+                return;
+
+            double time = playable.GetTime ( );
+            double ratio = time / clipInfo.duration;
+            float ratioF = (float) ratio;
+
+            foreach ( var data in toApply )
+            {
+                interpolator.Apply (data, ratioF);
+            }
+
+
+        }
+    }
+}

package/Runtime/InterpolationParam/AInterpolatePlayableDataProvider.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 527a60d8391b3fd44b7040de8f0d04ee

package/Runtime/InterpolationParam.meta

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

package/Runtime/Material/MaterialParamControlTrack.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Timeline;
+
+namespace AtlasV.Tools.Timeline
+{
+    [TrackBindingType (typeof (Material))]
+    [TrackClipType (typeof (ShaderParamControlClipFloat))]
+    [TrackClipType (typeof (ShaderParamControlClipColor))]
+    [TrackClipType (typeof (ShaderParamControlClipVector2))]
+    [TrackClipType (typeof (ShaderParamControlClipVector3))]
+    [TrackClipType (typeof (ShaderParamControlClipVector4))]
+    [TrackColor (0.3639196f, 0.8867924f, 0.4580367f)]
+    public class MaterialParamControlTrack : AInterpolateControlTrackDataProvider<Material, ShaderParamPlayable>, ITimelineDataProvider<Material>
+    {
+        public override List<Material> GetTrackedObject (Object userData)
+        {
+            if (userData is Material)
+            {
+                return new List<Material> ()
+                {
+                    userData as Material
+                };
+            }
+            return null;
+        }
+    }
+}

package/Runtime/Material/MaterialParamControlTrack.cs.meta

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