UnityExamples project update

UnityExamples.Unity5/Assets/DOTween Examples/CustomPlugin Example/CustomRangePlugin.cs

@@ -25,6 +25,13 @@ public class CustomRangePlugin : ABSTweenPlugin<CustomRange, CustomRange, NoOpti
         t.setter(t.startValue);
     }
 
+    // Sets the values in case of a From tween with a specific from value
+    public override void SetFrom(TweenerCore<CustomRange, CustomRange, NoOptions> t, CustomRange fromValue, bool setImmediately)
+    {
+        t.startValue = fromValue;
+        if (setImmediately) t.setter(fromValue);
+    }
+
     // Used by special plugins, just let it return the given value
     public override CustomRange ConvertToStartValue(TweenerCore<CustomRange, CustomRange, NoOptions> t, CustomRange value)
     {

UnityExamples.Unity5/Assets/Demigiant/DOTween/DOTween.XML

@@ -137,6 +137,17 @@
             Public so it can be used by external ease factories
             </summary>
         </member>
+        <member name="T:DG.Tweening.Core.Enums.NestedTweenFailureBehaviour">
+            <summary>
+            Behaviour in case a tween nested inside a Sequence fails
+            </summary>
+        </member>
+        <member name="F:DG.Tweening.Core.Enums.NestedTweenFailureBehaviour.TryToPreserveSequence">
+            <summary>If the Sequence contains other elements, kill the failed tween but preserve the rest</summary>
+        </member>
+        <member name="F:DG.Tweening.Core.Enums.NestedTweenFailureBehaviour.KillWholeSequence">
+            <summary>Kill the whole Sequence</summary>
+        </member>
         <member name="T:DG.Tweening.Core.Enums.UpdateNotice">
             <summary>
             Additional notices passed to plugins when updating.
@@ -153,11 +164,52 @@
             Lets the plugin know that we restarted or rewinded
             </summary>
         </member>
+        <member name="T:DG.Tweening.Core.Enums.RewindCallbackMode">
+            <summary>
+            OnRewind callback behaviour (can only be set via DOTween's Utility Panel)
+            </summary>
+        </member>
+        <member name="F:DG.Tweening.Core.Enums.RewindCallbackMode.FireIfPositionChanged">
+            <summary>
+            When calling Rewind or PlayBackwards/SmoothRewind, OnRewind callbacks will be fired only if the tween isn't already rewinded
+            </summary>
+        </member>
+        <member name="F:DG.Tweening.Core.Enums.RewindCallbackMode.FireAlwaysWithRewind">
+            <summary>
+            When calling Rewind, OnRewind callbacks will always be fired, even if the tween is already rewinded.
+            When calling PlayBackwards/SmoothRewind instead, OnRewind callbacks will be fired only if the tween isn't already rewinded
+            </summary>
+        </member>
+        <member name="F:DG.Tweening.Core.Enums.RewindCallbackMode.FireAlways">
+            <summary>
+            When calling Rewind or PlayBackwards/SmoothRewind, OnRewind callbacks will always be fired, even if the tween is already rewinded
+            </summary>
+        </member>
         <member name="T:DG.Tweening.Core.Extensions">
             <summary>
             Public only so custom shortcuts can access some of these methods
             </summary>
         </member>
+        <member name="M:DG.Tweening.Core.Extensions.SetSpecialStartupMode``1(``0,DG.Tweening.Core.Enums.SpecialStartupMode)">
+            <summary>
+            INTERNAL: used by DO shortcuts and Modules to set special startup mode
+            </summary>
+        </member>
+        <member name="M:DG.Tweening.Core.Extensions.Blendable``3(DG.Tweening.Core.TweenerCore{``0,``1,``2})">
+            <summary>
+            INTERNAL: used by DO shortcuts and Modules to set the tween as blendable
+            </summary>
+        </member>
+        <member name="M:DG.Tweening.Core.Extensions.NoFrom``3(DG.Tweening.Core.TweenerCore{``0,``1,``2})">
+            <summary>
+            INTERNAL: used by DO shortcuts and Modules to prevent a tween from using a From setup even if passed
+            </summary>
+        </member>
+        <member name="T:DG.Tweening.Core.DOTweenExternalCommand">
+            <summary>
+            Used to dispatch commands that need to be captured externally, usually by Modules
+            </summary>
+        </member>
         <member name="M:DG.Tweening.Core.Utils.Vector3FromAngle(System.Single,System.Single)">
             <summary>
             Returns a Vector3 with z = 0
@@ -168,6 +220,43 @@
             Returns the 2D angle between two vectors
             </summary>
         </member>
+        <member name="M:DG.Tweening.Core.Utils.Vector3AreApproximatelyEqual(UnityEngine.Vector3,UnityEngine.Vector3)">
+            <summary>
+            Uses approximate equality on each axis instead of Unity's Vector3 equality,
+            because the latter fails (in some cases) when assigning a Vector3 to a transform.position and then checking it.
+            </summary>
+        </member>
+        <member name="M:DG.Tweening.Core.Utils.GetLooseScriptType(System.String)">
+            <summary>
+            Looks for the type within all possible project assembly names
+            </summary>
+        </member>
+        <member name="M:DG.Tweening.Core.TweenerCore`3.ChangeStartValue(`1,System.Single)">
+            <summary>NO-GC METHOD: changes the start value of a tween and rewinds it (without pausing it).
+            Has no effect with tweens that are inside Sequences</summary>
+            <param name="newStartValue">The new start value</param>
+            <param name="newDuration">If bigger than 0 applies it as the new tween duration</param>
+        </member>
+        <member name="M:DG.Tweening.Core.TweenerCore`3.ChangeEndValue(`1,System.Boolean)">
+            <summary>NO-GC METHOD: changes the end value of a tween and rewinds it (without pausing it).
+            Has no effect with tweens that are inside Sequences</summary>
+            <param name="newEndValue">The new end value</param>
+            <param name="snapStartValue">If TRUE the start value will become the current target's value, otherwise it will stay the same</param>
+        </member>
+        <member name="M:DG.Tweening.Core.TweenerCore`3.ChangeEndValue(`1,System.Single,System.Boolean)">
+            <summary>NO-GC METHOD: changes the end value of a tween and rewinds it (without pausing it).
+            Has no effect with tweens that are inside Sequences</summary>
+            <param name="newEndValue">The new end value</param>
+            <param name="newDuration">If bigger than 0 applies it as the new tween duration</param>
+            <param name="snapStartValue">If TRUE the start value will become the current target's value, otherwise it will stay the same</param>
+        </member>
+        <member name="M:DG.Tweening.Core.TweenerCore`3.ChangeValues(`1,`1,System.Single)">
+            <summary>NO-GC METHOD: changes the start and end value of a tween and rewinds it (without pausing it).
+            Has no effect with tweens that are inside Sequences</summary>
+            <param name="newStartValue">The new start value</param>
+            <param name="newEndValue">The new end value</param>
+            <param name="newDuration">If bigger than 0 applies it as the new tween duration</param>
+        </member>
         <member name="T:DG.Tweening.Color2">
             <summary>
             Struct that stores two colors (used for LineRenderer tweens)
@@ -210,6 +299,9 @@
         <member name="M:DG.Tweening.CustomPlugins.PureQuaternionPlugin.SetFrom(DG.Tweening.Core.TweenerCore{UnityEngine.Quaternion,UnityEngine.Quaternion,DG.Tweening.Plugins.Options.NoOptions},System.Boolean)">
             <summary>INTERNAL: do not use</summary>
         </member>
+        <member name="M:DG.Tweening.CustomPlugins.PureQuaternionPlugin.SetFrom(DG.Tweening.Core.TweenerCore{UnityEngine.Quaternion,UnityEngine.Quaternion,DG.Tweening.Plugins.Options.NoOptions},UnityEngine.Quaternion,System.Boolean)">
+            <summary>INTERNAL: do not use</summary>
+        </member>
         <member name="M:DG.Tweening.CustomPlugins.PureQuaternionPlugin.ConvertToStartValue(DG.Tweening.Core.TweenerCore{UnityEngine.Quaternion,UnityEngine.Quaternion,DG.Tweening.Plugins.Options.NoOptions},UnityEngine.Quaternion)">
             <summary>INTERNAL: do not use</summary>
         </member>
@@ -238,6 +330,10 @@
             (like targets becoming null while a tween is playing).
             <para>Default: TRUE</para></summary>
         </member>
+        <member name="F:DG.Tweening.DOTween.nestedTweenFailureBehaviour">
+            <summary>Behaviour in case a tween nested inside a Sequence fails (caught by safe mode).
+            <para>Default: NestedTweenFailureBehaviour.TryToPreserveSequence</para></summary>
+        </member>
         <member name="F:DG.Tweening.DOTween.showUnityEditorReport">
             <summary>If TRUE you will get a DOTween report when exiting play mode (only in the Editor).
             Useful to know how many max Tweeners and Sequences you reached and optimize your final project accordingly.
@@ -264,6 +360,13 @@
             <summary>DOTween's log behaviour.
             <para>Default: LogBehaviour.ErrorsOnly</para></summary>
         </member>
+        <member name="F:DG.Tweening.DOTween.onWillLog">
+            <summary>Used to intercept DOTween's logs. If this method isn't NULL, DOTween will call it before writing a log via Unity's own Debug log methods.<para/>
+            Return TRUE if you want DOTween to proceed with the log, FALSE otherwise.<para/>
+            This method must return a <code>bool</code> and accept two parameters:<para/>
+            - <code>LogType</code>: the type of Unity log that DOTween is trying to log<para/>
+            - <code>object</code>: the log message that DOTween wants to log</summary>
+        </member>
         <member name="F:DG.Tweening.DOTween.drawGizmos">
             <summary>If TRUE draws path gizmos in Unity Editor (if the gizmos button is active).
             Deactivate this if you want to avoid gizmos overhead while in Unity Editor</summary>
@@ -304,6 +407,9 @@
             <summary>Default period used for eases
             <para>Default: 0</para></summary>
         </member>
+        <member name="F:DG.Tweening.DOTween.instance">
+            <summary>Used internally. Assigned/removed by DOTweenComponent.Create/DestroyInstance</summary>
+        </member>
         <member name="M:DG.Tweening.DOTween.Init(System.Nullable{System.Boolean},System.Nullable{System.Boolean},System.Nullable{DG.Tweening.LogBehaviour})">
             <summary>
             Must be called once, before the first ever DOTween call/reference,
@@ -366,6 +472,13 @@
             BEWARE: this is a slightly expensive operation so use it with care
             </summary>
         </member>
+        <member name="M:DG.Tweening.DOTween.ManualUpdate(System.Single,System.Single)">
+            <summary>
+            Updates all tweens that are set to <see cref="F:DG.Tweening.UpdateType.Manual"/>.
+            </summary>
+            <param name="deltaTime">Manual deltaTime</param>
+            <param name="unscaledDeltaTime">Unscaled delta time (used with tweens set as timeScaleIndependent)</param>
+        </member>
         <member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{System.Single},DG.Tweening.Core.DOSetter{System.Single},System.Single,System.Single)">
             <summary>Tweens a property or field to the given value using default plugins</summary>
             <param name="getter">A getter for the field or property to tween.
@@ -721,34 +834,38 @@
             A tween is considered as playing even if its delay is actually playing
             </summary>
         </member>
-        <member name="M:DG.Tweening.DOTween.PlayingTweens">
+        <member name="M:DG.Tweening.DOTween.PlayingTweens(System.Collections.Generic.List{DG.Tweening.Tween})">
             <summary>
             Returns a list of all active tweens in a playing state.
             Returns NULL if there are no active playing tweens.
             <para>Beware: each time you call this method a new list is generated, so use it for debug only</para>
             </summary>
+            <param name="fillableList">If NULL creates a new list, otherwise clears and fills this one (and thus saves allocations)</param>
         </member>
-        <member name="M:DG.Tweening.DOTween.PausedTweens">
+        <member name="M:DG.Tweening.DOTween.PausedTweens(System.Collections.Generic.List{DG.Tweening.Tween})">
             <summary>
             Returns a list of all active tweens in a paused state.
             Returns NULL if there are no active paused tweens.
             <para>Beware: each time you call this method a new list is generated, so use it for debug only</para>
             </summary>
+            <param name="fillableList">If NULL creates a new list, otherwise clears and fills this one (and thus saves allocations)</param>
         </member>
-        <member name="M:DG.Tweening.DOTween.TweensById(System.Object,System.Boolean)">
+        <member name="M:DG.Tweening.DOTween.TweensById(System.Object,System.Boolean,System.Collections.Generic.List{DG.Tweening.Tween})">
             <summary>
             Returns a list of all active tweens with the given id.
             Returns NULL if there are no active tweens with the given id.
             <para>Beware: each time you call this method a new list is generated</para>
-            <param name="playingOnly">If TRUE returns only the tweens with the given ID that are currently playing</param>
             </summary>
+            <param name="playingOnly">If TRUE returns only the tweens with the given ID that are currently playing</param>
+            <param name="fillableList">If NULL creates a new list, otherwise clears and fills this one (and thus saves allocations)</param>
         </member>
-        <member name="M:DG.Tweening.DOTween.TweensByTarget(System.Object,System.Boolean)">
+        <member name="M:DG.Tweening.DOTween.TweensByTarget(System.Object,System.Boolean,System.Collections.Generic.List{DG.Tweening.Tween})">
             <summary>
             Returns a list of all active tweens with the given target.
             Returns NULL if there are no active tweens with the given target.
             <para>Beware: each time you call this method a new list is generated</para>
             <param name="playingOnly">If TRUE returns only the tweens with the given target that are currently playing</param>
+            <param name="fillableList">If NULL creates a new list, otherwise clears and fills this one (and thus saves allocations)</param>
             </summary>
         </member>
         <member name="T:DG.Tweening.DOVirtual">
@@ -861,6 +978,44 @@
             <param name="sequencesCapacity">Max Sequences capacity.
             Default: 50</param>
         </member>
+        <member name="T:DG.Tweening.LinkBehaviour">
+            <summary>
+            Behaviour that can be assigned when chaining a SetLink to a tween
+            </summary>
+        </member>
+        <member name="F:DG.Tweening.LinkBehaviour.PauseOnDisable">
+            <summary>Pauses the tween when the link target is disabled</summary>
+        </member>
+        <member name="F:DG.Tweening.LinkBehaviour.PauseOnDisablePlayOnEnable">
+            <summary>Pauses the tween when the link target is disabled, plays it when it's enabled</summary>
+        </member>
+        <member name="F:DG.Tweening.LinkBehaviour.PauseOnDisableRestartOnEnable">
+            <summary>Pauses the tween when the link target is disabled, restarts it when it's enabled</summary>
+        </member>
+        <member name="F:DG.Tweening.LinkBehaviour.PlayOnEnable">
+            <summary>Plays the tween when the link target is enabled</summary>
+        </member>
+        <member name="F:DG.Tweening.LinkBehaviour.RestartOnEnable">
+            <summary>Restarts the tween when the link target is enabled</summary>
+        </member>
+        <member name="F:DG.Tweening.LinkBehaviour.KillOnDisable">
+            <summary>Kills the tween when the link target is disabled</summary>
+        </member>
+        <member name="F:DG.Tweening.LinkBehaviour.KillOnDestroy">
+            <summary>Kills the tween when the link target is destroyed (becomes NULL). This is always active even if another behaviour is chosen</summary>
+        </member>
+        <member name="F:DG.Tweening.LinkBehaviour.CompleteOnDisable">
+            <summary>Completes the tween when the link target is disabled</summary>
+        </member>
+        <member name="F:DG.Tweening.LinkBehaviour.CompleteAndKillOnDisable">
+            <summary>Completes and kills the tween when the link target is disabled</summary>
+        </member>
+        <member name="F:DG.Tweening.LinkBehaviour.RewindOnDisable">
+            <summary>Rewinds the tween (delay excluded) when the link target is disabled</summary>
+        </member>
+        <member name="F:DG.Tweening.LinkBehaviour.RewindAndKillOnDisable">
+            <summary>Rewinds and kills the tween when the link target is disabled</summary>
+        </member>
         <member name="T:DG.Tweening.PathMode">
             <summary>
             Path mode (used to determine correct LookAt orientation)
@@ -889,6 +1044,9 @@
         <member name="F:DG.Tweening.PathType.CatmullRom">
             <summary>Curved path (which uses Catmull-Rom curves)</summary>
         </member>
+        <member name="F:DG.Tweening.PathType.CubicBezier">
+            <summary><code>EXPERIMENTAL: </code>Curved path (which uses Cubic Bezier curves, where each point requires two extra control points)</summary>
+        </member>
         <member name="T:DG.Tweening.Plugins.Core.PathCore.ControlPoint">
             <summary>
             Path control point
@@ -1201,16 +1359,6 @@
             Methods that extend known Unity objects and allow to directly create and control tweens from their instances
             </summary>
         </member>
-        <member name="M:DG.Tweening.ShortcutExtensions.DOFade(UnityEngine.AudioSource,System.Single,System.Single)">
-            <summary>Tweens an AudioSource's volume to the given value.
-            Also stores the AudioSource as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach (0 to 1)</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions.DOPitch(UnityEngine.AudioSource,System.Single,System.Single)">
-            <summary>Tweens an AudioSource's pitch to the given value.
-            Also stores the AudioSource as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
         <member name="M:DG.Tweening.ShortcutExtensions.DOAspect(UnityEngine.Camera,System.Single,System.Single)">
             <summary>Tweens a Camera's <code>aspect</code> to the given value.
             Also stores the camera as the tween's target so it can be used for filtered operations</summary>
@@ -1326,6 +1474,13 @@
             <param name="property">The name of the material property to tween (like _Tint or _SpecColor)</param>
             <param name="duration">The duration of the tween</param>
         </member>
+        <member name="M:DG.Tweening.ShortcutExtensions.DOColor(UnityEngine.Material,UnityEngine.Color,System.Int32,System.Single)">
+            <summary>Tweens a Material's named color property with the given ID to the given value.
+            Also stores the material as the tween's target so it can be used for filtered operations</summary>
+            <param name="endValue">The end value to reach</param>
+            <param name="propertyID">The ID of the material property to tween (also called nameID in Unity's manual)</param>
+            <param name="duration">The duration of the tween</param>
+        </member>
         <member name="M:DG.Tweening.ShortcutExtensions.DOFade(UnityEngine.Material,System.Single,System.Single)">
             <summary>Tweens a Material's alpha color to the given value
             (will have no effect unless your material supports transparency).
@@ -1340,6 +1495,14 @@
             <param name="property">The name of the material property to tween (like _Tint or _SpecColor)</param>
             <param name="duration">The duration of the tween</param>
         </member>
+        <member name="M:DG.Tweening.ShortcutExtensions.DOFade(UnityEngine.Material,System.Single,System.Int32,System.Single)">
+            <summary>Tweens a Material's alpha color with the given ID to the given value
+            (will have no effect unless your material supports transparency).
+            Also stores the material as the tween's target so it can be used for filtered operations</summary>
+            <param name="endValue">The end value to reach</param>
+            <param name="propertyID">The ID of the material property to tween (also called nameID in Unity's manual)</param>
+            <param name="duration">The duration of the tween</param>
+        </member>
         <member name="M:DG.Tweening.ShortcutExtensions.DOFloat(UnityEngine.Material,System.Single,System.String,System.Single)">
             <summary>Tweens a Material's named float property to the given value.
             Also stores the material as the tween's target so it can be used for filtered operations</summary>
@@ -1347,6 +1510,13 @@
             <param name="property">The name of the material property to tween</param>
             <param name="duration">The duration of the tween</param>
         </member>
+        <member name="M:DG.Tweening.ShortcutExtensions.DOFloat(UnityEngine.Material,System.Single,System.Int32,System.Single)">
+            <summary>Tweens a Material's named float property with the given ID to the given value.
+            Also stores the material as the tween's target so it can be used for filtered operations</summary>
+            <param name="endValue">The end value to reach</param>
+            <param name="propertyID">The ID of the material property to tween (also called nameID in Unity's manual)</param>
+            <param name="duration">The duration of the tween</param>
+        </member>
         <member name="M:DG.Tweening.ShortcutExtensions.DOOffset(UnityEngine.Material,UnityEngine.Vector2,System.Single)">
             <summary>Tweens a Material's texture offset to the given value.
             Also stores the material as the tween's target so it can be used for filtered operations</summary>
@@ -1380,80 +1550,12 @@
             <param name="property">The name of the material property to tween</param>
             <param name="duration">The duration of the tween</param>
         </member>
-        <member name="M:DG.Tweening.ShortcutExtensions.DOMove(UnityEngine.Rigidbody,UnityEngine.Vector3,System.Single,System.Boolean)">
+        <member name="M:DG.Tweening.ShortcutExtensions.DOVector(UnityEngine.Material,UnityEngine.Vector4,System.Int32,System.Single)">
-            <summary>Tweens a Rigidbody's position to the given value.
+            <summary>Tweens a Material's named Vector property with the given ID to the given value.
-            Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+            Also stores the material as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions.DOMoveX(UnityEngine.Rigidbody,System.Single,System.Single,System.Boolean)">
-            <summary>Tweens a Rigidbody's X position to the given value.
-            Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions.DOMoveY(UnityEngine.Rigidbody,System.Single,System.Single,System.Boolean)">
-            <summary>Tweens a Rigidbody's Y position to the given value.
-            Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions.DOMoveZ(UnityEngine.Rigidbody,System.Single,System.Single,System.Boolean)">
-            <summary>Tweens a Rigidbody's Z position to the given value.
-            Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions.DORotate(UnityEngine.Rigidbody,UnityEngine.Vector3,System.Single,DG.Tweening.RotateMode)">
-            <summary>Tweens a Rigidbody's rotation to the given value.
-            Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="mode">Rotation mode</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions.DOLookAt(UnityEngine.Rigidbody,UnityEngine.Vector3,System.Single,DG.Tweening.AxisConstraint,System.Nullable{UnityEngine.Vector3})">
-            <summary>Tweens a Rigidbody's rotation so that it will look towards the given position.
-            Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
-            <param name="towards">The position to look at</param><param name="duration">The duration of the tween</param>
-            <param name="axisConstraint">Eventual axis constraint for the rotation</param>
-            <param name="up">The vector that defines in which direction up is (default: Vector3.up)</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions.DOJump(UnityEngine.Rigidbody,UnityEngine.Vector3,System.Single,System.Int32,System.Single,System.Boolean)">
-            <summary>Tweens a Rigidbody's position to the given value, while also applying a jump effect along the Y axis.
-            Returns a Sequence instead of a Tweener.
-            Also stores the Rigidbody as the tween's target so it can be used for filtered operations</summary>
             <param name="endValue">The end value to reach</param>
-            <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
+            <param name="propertyID">The ID of the material property to tween (also called nameID in Unity's manual)</param>
-            <param name="numJumps">Total number of jumps</param>
             <param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions.DOPath(UnityEngine.Rigidbody,UnityEngine.Vector3[],System.Single,DG.Tweening.PathType,DG.Tweening.PathMode,System.Int32,System.Nullable{UnityEngine.Color})">
-            <summary>Tweens a Rigidbody's position through the given path waypoints, using the chosen path algorithm.
-            Also stores the Rigidbody as the tween's target so it can be used for filtered operations.
-            <para>NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened.</para>
-            <para>BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
-            If you plan to publish there you should use a regular transform.DOPath.</para></summary>
-            <param name="path">The waypoints to go through</param>
-            <param name="duration">The duration of the tween</param>
-            <param name="pathType">The type of path: Linear (straight path) or CatmullRom (curved CatmullRom path)</param>
-            <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
-            <param name="resolution">The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved paths but are more expensive.
-            Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
-            <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions.DOLocalPath(UnityEngine.Rigidbody,UnityEngine.Vector3[],System.Single,DG.Tweening.PathType,DG.Tweening.PathMode,System.Int32,System.Nullable{UnityEngine.Color})">
-            <summary>Tweens a Rigidbody's localPosition through the given path waypoints, using the chosen path algorithm.
-            Also stores the Rigidbody as the tween's target so it can be used for filtered operations
-            <para>NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened.</para>
-            <para>BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
-            If you plan to publish there you should use a regular transform.DOLocalPath.</para></summary>
-            <param name="path">The waypoint to go through</param>
-            <param name="duration">The duration of the tween</param>
-            <param name="pathType">The type of path: Linear (straight path) or CatmullRom (curved CatmullRom path)</param>
-            <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
-            <param name="resolution">The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive.
-            Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
-            <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
         </member>
         <member name="M:DG.Tweening.ShortcutExtensions.DOResize(UnityEngine.TrailRenderer,System.Single,System.Single,System.Single)">
             <summary>Tweens a TrailRenderer's startWidth/endWidth to the given value.
@@ -1705,6 +1807,22 @@
             Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
             <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
         </member>
+        <member name="M:DG.Tweening.ShortcutExtensions.DOPath(UnityEngine.Transform,DG.Tweening.Plugins.Core.PathCore.Path,System.Single,DG.Tweening.PathMode)">
+            <summary>IMPORTANT: Unless you really know what you're doing, you should use the overload that accepts a Vector3 array instead.<para/>
+            Tweens a Transform's position via the given path.
+            Also stores the transform as the tween's target so it can be used for filtered operations</summary>
+            <param name="path">The path to use</param>
+            <param name="duration">The duration of the tween</param>
+            <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
+        </member>
+        <member name="M:DG.Tweening.ShortcutExtensions.DOLocalPath(UnityEngine.Transform,DG.Tweening.Plugins.Core.PathCore.Path,System.Single,DG.Tweening.PathMode)">
+            <summary>IMPORTANT: Unless you really know what you're doing, you should use the overload that accepts a Vector3 array instead.<para/>
+            Tweens a Transform's localPosition via the given path.
+            Also stores the transform as the tween's target so it can be used for filtered operations</summary>
+            <param name="path">The path to use</param>
+            <param name="duration">The duration of the tween</param>
+            <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
+        </member>
         <member name="M:DG.Tweening.ShortcutExtensions.DOTimeScale(DG.Tweening.Tween,System.Single,System.Single)">
             <summary>Tweens a Tween's timeScale to the given value.
             Also stores the Tween as the tween's target so it can be used for filtered operations</summary>
@@ -1733,6 +1851,15 @@
             <param name="property">The name of the material property to tween (like _Tint or _SpecColor)</param>
             <param name="duration">The duration of the tween</param>
         </member>
+        <member name="M:DG.Tweening.ShortcutExtensions.DOBlendableColor(UnityEngine.Material,UnityEngine.Color,System.Int32,System.Single)">
+            <summary>Tweens a Material's named color property with the given ID to the given value,
+            in a way that allows other DOBlendableColor tweens to work together on the same target,
+            instead than fight each other as multiple DOColor would do.
+            Also stores the Material as the tween's target so it can be used for filtered operations</summary>
+            <param name="endValue">The value to tween to</param>
+            <param name="propertyID">The ID of the material property to tween (also called nameID in Unity's manual)</param>
+            <param name="duration">The duration of the tween</param>
+        </member>
         <member name="M:DG.Tweening.ShortcutExtensions.DOBlendableMoveBy(UnityEngine.Transform,UnityEngine.Vector3,System.Single,System.Boolean)">
             <summary>Tweens a Transform's position BY the given value (as if you chained a <code>SetRelative</code>),
             in a way that allows other DOBlendableMove tweens to work together on the same target,
@@ -1765,6 +1892,17 @@
             <param name="byValue">The value to tween by</param><param name="duration">The duration of the tween</param>
             <param name="mode">Rotation mode</param>
         </member>
+        <member name="M:DG.Tweening.ShortcutExtensions.DOBlendablePunchRotation(UnityEngine.Transform,UnityEngine.Vector3,System.Single,System.Int32,System.Single)">
+            <summary>Punches a Transform's localRotation BY the given value and then back to the starting one
+            as if it was connected to the starting rotation via an elastic. Does it in a way that allows other
+            DOBlendableRotate tweens to work together on the same target</summary>
+            <param name="punch">The punch strength (added to the Transform's current rotation)</param>
+            <param name="duration">The duration of the tween</param>
+            <param name="vibrato">Indicates how much will the punch vibrate</param>
+            <param name="elasticity">Represents how much (0 to 1) the vector will go beyond the starting rotation when bouncing backwards.
+            1 creates a full oscillation between the punch rotation and the opposite rotation,
+            while 0 oscillates only between the punch and the start rotation</param>
+        </member>
         <member name="M:DG.Tweening.ShortcutExtensions.DOBlendableScaleBy(UnityEngine.Transform,UnityEngine.Vector3,System.Single)">
             <summary>Tweens a Transform's localScale BY the given value (as if you chained a <code>SetRelative</code>),
             in a way that allows other DOBlendableScale tweens to work together on the same target,
@@ -2077,17 +2215,40 @@
             </summary>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.SetAutoKill``1(``0)">
-            <summary>Sets the autoKill behaviour of the tween. 
+            <summary>Sets the autoKill behaviour of the tween to TRUE. 
-            Has no effect if the tween has already started</summary>
+            <code>Has no effect</code> if the tween has already started or if it's added to a Sequence</summary>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.SetAutoKill``1(``0,System.Boolean)">
             <summary>Sets the autoKill behaviour of the tween. 
-            Has no effect if the tween has already started</summary>
+            <code>Has no effect</code> if the tween has already started or if it's added to a Sequence</summary>
             <param name="autoKillOnCompletion">If TRUE the tween will be automatically killed when complete</param>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.SetId``1(``0,System.Object)">
-            <summary>Sets an ID for the tween, which can then be used as a filter with DOTween's static methods.</summary>
+            <summary>Sets an ID for the tween (<see cref="F:DG.Tweening.Tween.id"/>), which can then be used as a filter with DOTween's static methods.</summary>
-            <param name="id">The ID to assign to this tween. Can be an int, a string, an object or anything else.</param>
+            <param name="objectId">The ID to assign to this tween. Can be an int, a string, an object or anything else.</param>
+        </member>
+        <member name="M:DG.Tweening.TweenSettingsExtensions.SetId``1(``0,System.String)">
+            <summary>Sets a string ID for the tween (<see cref="F:DG.Tweening.Tween.stringId"/>), which can then be used as a filter with DOTween's static methods.<para/>
+            Filtering via string is 2X faster than using an object as an ID (using the alternate obejct overload)</summary>
+            <param name="stringId">The string ID to assign to this tween.</param>
+        </member>
+        <member name="M:DG.Tweening.TweenSettingsExtensions.SetId``1(``0,System.Int32)">
+            <summary>Sets an int ID for the tween (<see cref="F:DG.Tweening.Tween.intId"/>), which can then be used as a filter with DOTween's static methods.<para/>
+            Filtering via int is 4X faster than via object, 2X faster than via string (using the alternate object/string overloads)</summary>
+            <param name="intId">The int ID to assign to this tween.</param>
+        </member>
+        <member name="M:DG.Tweening.TweenSettingsExtensions.SetLink``1(``0,UnityEngine.GameObject)">
+            <summary>Allows to link this tween to a GameObject
+            so that it will be automatically killed when the GameObject is destroyed.
+            <code>Has no effect</code> if the tween is added to a Sequence</summary>
+            <param name="gameObject">The link target (unrelated to the target set via <code>SetTarget</code>)</param>
+        </member>
+        <member name="M:DG.Tweening.TweenSettingsExtensions.SetLink``1(``0,UnityEngine.GameObject,DG.Tweening.LinkBehaviour)">
+            <summary>Allows to link this tween to a GameObject and assign a behaviour depending on it.
+            This will also automatically kill the tween when the GameObject is destroyed.
+            <code>Has no effect</code> if the tween is added to a Sequence</summary>
+            <param name="gameObject">The link target (unrelated to the target set via <code>SetTarget</code>)</param>
+            <param name="behaviour">The behaviour to use (<see cref="F:DG.Tweening.LinkBehaviour.KillOnDestroy"/> is always evaluated even if you choose another one)</param>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.SetTarget``1(``0,System.Object)">
             <summary>Sets the target for the tween, which can then be used as a filter with DOTween's static methods.
@@ -2161,43 +2322,43 @@
             <param name="isIndependentUpdate">If TRUE the tween will ignore Unity's Time.timeScale</param>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.OnStart``1(``0,DG.Tweening.TweenCallback)">
-            <summary>Sets the onStart callback for the tween.
+            <summary>Sets the <code>onStart</code> callback for the tween, clearing any previous <code>onStart</code> callback that was set.
             Called the first time the tween is set in a playing state, after any eventual delay</summary>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.OnPlay``1(``0,DG.Tweening.TweenCallback)">
-            <summary>Sets the onPlay callback for the tween.
+            <summary>Sets the <code>onPlay</code> callback for the tween, clearing any previous <code>onPlay</code> callback that was set.
             Called when the tween is set in a playing state, after any eventual delay.
             Also called each time the tween resumes playing from a paused state</summary>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.OnPause``1(``0,DG.Tweening.TweenCallback)">
-            <summary>Sets the onPlay callback for the tween.
+            <summary>Sets the <code>onPause</code> callback for the tween, clearing any previous <code>onPause</code> callback that was set.
             Called when the tween state changes from playing to paused.
             If the tween has autoKill set to FALSE, this is called also when the tween reaches completion.</summary>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.OnRewind``1(``0,DG.Tweening.TweenCallback)">
-            <summary>Sets the onRewind callback for the tween.
+            <summary>Sets the <code>onRewind</code> callback for the tween, clearing any previous <code>onRewind</code> callback that was set.
             Called when the tween is rewinded,
             either by calling <code>Rewind</code> or by reaching the start position while playing backwards.
             Rewinding a tween that is already rewinded will not fire this callback</summary>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.OnUpdate``1(``0,DG.Tweening.TweenCallback)">
-            <summary>Sets the onUpdate callback for the tween.
+            <summary>Sets the <code>onUpdate</code> callback for the tween, clearing any previous <code>onUpdate</code> callback that was set.
             Called each time the tween updates</summary>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.OnStepComplete``1(``0,DG.Tweening.TweenCallback)">
-            <summary>Sets the onStepComplete callback for the tween.
+            <summary>Sets the <code>onStepComplete</code> callback for the tween, clearing any previous <code>onStepComplete</code> callback that was set.
             Called the moment the tween completes one loop cycle, even when going backwards</summary>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.OnComplete``1(``0,DG.Tweening.TweenCallback)">
-            <summary>Sets the onComplete callback for the tween.
+            <summary>Sets the <code>onComplete</code> callback for the tween, clearing any previous <code>onComplete</code> callback that was set.
             Called the moment the tween reaches its final forward position, loops included</summary>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.OnKill``1(``0,DG.Tweening.TweenCallback)">
-            <summary>Sets the onKill callback for the tween.
+            <summary>Sets the <code>onKill</code> callback for the tween, clearing any previous <code>onKill</code> callback that was set.
             Called the moment the tween is killed</summary>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.OnWaypointChange``1(``0,DG.Tweening.TweenCallback{System.Int32})">
-            <summary>Sets the onWaypointChange callback for the tween.
+            <summary>Sets the <code>onWaypointChange</code> callback for the tween, clearing any previous <code>onWaypointChange</code> callback that was set.
             Called when a path tween's current waypoint changes</summary>
         </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.SetAs``1(``0,DG.Tweening.Tween)">
@@ -2270,6 +2431,24 @@
             then immediately sends the target to the previously set endValue.</summary>
             <param name="isRelative">If TRUE the FROM value will be calculated as relative to the current one</param>
         </member>
+        <member name="M:DG.Tweening.TweenSettingsExtensions.From``3(DG.Tweening.Core.TweenerCore{``0,``1,``2},``1,System.Boolean)">
+            <summary>Changes a TO tween into a FROM tween: sets the tween's starting value to the given one
+            and eventually sets the tween's target to that value immediately.</summary>
+            <param name="fromValue">Value to start from</param>
+            <param name="setImmediately">If TRUE sets the target to from value immediately, otherwise waits for the tween to start</param>
+        </member>
+        <member name="M:DG.Tweening.TweenSettingsExtensions.From(DG.Tweening.Core.TweenerCore{UnityEngine.Color,UnityEngine.Color,DG.Tweening.Plugins.Options.ColorOptions},System.Single,System.Boolean)">
+            <summary>Changes a TO tween into a FROM tween: sets the tween's starting value to the given one
+            and eventually sets the tween's target to that value immediately.</summary>
+            <param name="fromAlphaValue">Alpha value to start from (in case of Fade tweens)</param>
+            <param name="setImmediately">If TRUE sets the target to from value immediately, otherwise waits for the tween to start</param>
+        </member>
+        <member name="M:DG.Tweening.TweenSettingsExtensions.From(DG.Tweening.Core.TweenerCore{UnityEngine.Vector3,UnityEngine.Vector3,DG.Tweening.Plugins.Options.VectorOptions},System.Single,System.Boolean)">
+            <summary>Changes a TO tween into a FROM tween: sets the tween's starting value to the given one
+            and eventually sets the tween's target to that value immediately.</summary>
+            <param name="fromValue">Value to start from (in case of Vector tweens that act on a single coordinate or scale tweens)</param>
+            <param name="setImmediately">If TRUE sets the target to from value immediately, otherwise waits for the tween to start</param>
+        </member>
         <member name="M:DG.Tweening.TweenSettingsExtensions.SetDelay``1(``0,System.Single)">
             <summary>Sets a delayed startup for the tween.
             <para>Has no effect on Sequences or if the tween has already started</para></summary>
@@ -2423,10 +2602,18 @@
             <summary>If TRUE the tween wil go backwards</summary>
         </member>
         <member name="F:DG.Tweening.Tween.id">
-            <summary>Id (usable for filtering with DOTween static methods). Can be an int, a string, an object, or anything else</summary>
+            <summary>Object ID (usable for filtering with DOTween static methods). Can be anything except a string or an int
+            (use <see cref="F:DG.Tweening.Tween.stringId"/> or <see cref="F:DG.Tweening.Tween.intId"/> for those)</summary>
+        </member>
+        <member name="F:DG.Tweening.Tween.stringId">
+            <summary>String ID (usable for filtering with DOTween static methods). 2X faster than using an object id</summary>
+        </member>
+        <member name="F:DG.Tweening.Tween.intId">
+            <summary>Int ID (usable for filtering with DOTween static methods). 4X faster than using an object id, 2X faster than using a string id.
+            Default is -999 so avoid using an ID like that or it will capture all unset intIds</summary>
         </member>
         <member name="F:DG.Tweening.Tween.target">
-            <summary>Tween target (usable for filtering with DOTween static methods). Automatically set by tween creation shorcuts</summary>
+            <summary>Tween target (usable for filtering with DOTween static methods). Automatically set by tween creation shortcuts</summary>
         </member>
         <member name="F:DG.Tweening.Tween.onPlay">
             <summary>Called when the tween is set in a playing state, after any eventual delay.
@@ -2456,9 +2643,21 @@
         <member name="F:DG.Tweening.Tween.onWaypointChange">
             <summary>Called when a path tween's current waypoint changes</summary>
         </member>
+        <member name="P:DG.Tweening.Tween.isRelative">
+            <summary>Tweeners-only (ignored by Sequences), returns TRUE if the tween was set as relative</summary>
+        </member>
+        <member name="P:DG.Tweening.Tween.active">
+            <summary>FALSE when tween is (or should be) despawned - set only by TweenManager</summary>
+        </member>
         <member name="P:DG.Tweening.Tween.fullPosition">
             <summary>Gets and sets the time position (loops included, delays excluded) of the tween</summary>
         </member>
+        <member name="P:DG.Tweening.Tween.playedOnce">
+            <summary>TRUE after the tween was set in a play state at least once, AFTER any delay is elapsed</summary>
+        </member>
+        <member name="P:DG.Tweening.Tween.position">
+            <summary>Time position within a single loop cycle</summary>
+        </member>
         <member name="T:DG.Tweening.Tweener">
             <summary>
             Animates a single value
@@ -2509,5 +2708,8 @@
         <member name="F:DG.Tweening.UpdateType.Fixed">
             <summary>Updates using FixedUpdate calls</summary>
         </member>
+        <member name="F:DG.Tweening.UpdateType.Manual">
+            <summary>Updates using manual update calls</summary>
+        </member>
     </members>
 </doc>

UnityExamples.Unity5/Assets/Demigiant/DOTween/DOTween43.dll.mdb.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: daa90d7807e5d524ea1efa4d20b2de6f
-timeCreated: 1427036874
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/DOTween43.dll.meta

@@ -1,24 +0,0 @@
-fileFormatVersion: 2
-guid: 96124212a8a434c4baaaff8cf6006657
-timeCreated: 1427036875
-licenseType: Pro
-PluginImporter:
-  serializedVersion: 1
-  iconMap: {}
-  executionOrder: {}
-  isPreloaded: 0
-  platformData:
-    Any:
-      enabled: 1
-      settings: {}
-    Editor:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-    WindowsStoreApps:
-      enabled: 0
-      settings:
-        CPU: AnyCPU
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/DOTween43.xml

@@ -1,85 +0,0 @@
-<?xml version="1.0"?>
-<doc>
-    <assembly>
-        <name>DOTween43</name>
-    </assembly>
-    <members>
-        <member name="T:DG.Tweening.ShortcutExtensions43">
-            <summary>
-            Methods that extend known Unity objects and allow to directly create and control tweens from their instances.
-            These, as all DOTween43 methods, require Unity 4.3 or later.
-            </summary>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions43.DOGradientColor(UnityEngine.Material,UnityEngine.Gradient,System.Single)">
-            <summary>Tweens a Material's color using the given gradient
-            (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
-            Also stores the image as the tween's target so it can be used for filtered operations</summary>
-            <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions43.DOGradientColor(UnityEngine.Material,UnityEngine.Gradient,System.String,System.Single)">
-            <summary>Tweens a Material's named color property using the given gradient
-            (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
-            Also stores the image as the tween's target so it can be used for filtered operations</summary>
-            <param name="gradient">The gradient to use</param>
-            <param name="property">The name of the material property to tween (like _Tint or _SpecColor)</param>
-            <param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions43.DOColor(UnityEngine.SpriteRenderer,UnityEngine.Color,System.Single)">
-            <summary>Tweens a SpriteRenderer's color to the given value.
-            Also stores the spriteRenderer as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions43.DOFade(UnityEngine.SpriteRenderer,System.Single,System.Single)">
-            <summary>Tweens a Material's alpha color to the given value.
-            Also stores the spriteRenderer as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions43.DOGradientColor(UnityEngine.SpriteRenderer,UnityEngine.Gradient,System.Single)">
-            <summary>Tweens a SpriteRenderer's color using the given gradient
-            (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
-            Also stores the image as the tween's target so it can be used for filtered operations</summary>
-            <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions43.DOMove(UnityEngine.Rigidbody2D,UnityEngine.Vector2,System.Single,System.Boolean)">
-            <summary>Tweens a Rigidbody2D's position to the given value.
-            Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions43.DOMoveX(UnityEngine.Rigidbody2D,System.Single,System.Single,System.Boolean)">
-            <summary>Tweens a Rigidbody2D's X position to the given value.
-            Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions43.DOMoveY(UnityEngine.Rigidbody2D,System.Single,System.Single,System.Boolean)">
-            <summary>Tweens a Rigidbody2D's Y position to the given value.
-            Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions43.DORotate(UnityEngine.Rigidbody2D,System.Single,System.Single)">
-            <summary>Tweens a Rigidbody2D's rotation to the given value.
-            Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions43.DOJump(UnityEngine.Rigidbody2D,UnityEngine.Vector2,System.Single,System.Int32,System.Single,System.Boolean)">
-            <summary>Tweens a Rigidbody2D's position to the given value, while also applying a jump effect along the Y axis.
-            Returns a Sequence instead of a Tweener.
-            Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations.
-            <para>IMPORTANT: a rigidbody2D can't be animated in a jump arc using MovePosition, so the tween will directly set the position</para></summary>
-            <param name="endValue">The end value to reach</param>
-            <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
-            <param name="numJumps">Total number of jumps</param>
-            <param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions43.DOBlendableColor(UnityEngine.SpriteRenderer,UnityEngine.Color,System.Single)">
-            <summary>Tweens a SpriteRenderer's color to the given value,
-            in a way that allows other DOBlendableColor tweens to work together on the same target,
-            instead than fight each other as multiple DOColor would do.
-            Also stores the SpriteRenderer as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
-        </member>
-    </members>
-</doc>

UnityExamples.Unity5/Assets/Demigiant/DOTween/DOTween43.xml.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: bee01d69fe6a7fe40b5abe7cf7256796
-timeCreated: 1427036876
-licenseType: Pro
-TextScriptImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/DOTween46.dll.mdb.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 0cefc8c9f88432a4691eda55a1455277
-timeCreated: 1427036874
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/DOTween46.dll.meta

@@ -1,24 +0,0 @@
-fileFormatVersion: 2
-guid: e533a471b73bc124e9b533b673c8fcde
-timeCreated: 1427036876
-licenseType: Pro
-PluginImporter:
-  serializedVersion: 1
-  iconMap: {}
-  executionOrder: {}
-  isPreloaded: 0
-  platformData:
-    Any:
-      enabled: 1
-      settings: {}
-    Editor:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-    WindowsStoreApps:
-      enabled: 0
-      settings:
-        CPU: AnyCPU
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/DOTween46.xml

@@ -1,261 +0,0 @@
-<?xml version="1.0"?>
-<doc>
-    <assembly>
-        <name>DOTween46</name>
-    </assembly>
-    <members>
-        <member name="T:DG.Tweening.DOTweenUtils46">
-            <summary>
-            Various utils that require Unity 4.6 or later
-            </summary>
-        </member>
-        <member name="M:DG.Tweening.DOTweenUtils46.SwitchToRectTransform(UnityEngine.RectTransform,UnityEngine.RectTransform)">
-            <summary>
-            Converts the anchoredPosition of the first RectTransform to the second RectTransform,
-            taking into consideration offset, anchors and pivot, and returns the new anchoredPosition
-            </summary>
-        </member>
-        <member name="T:DG.Tweening.ShortcutExtensions46">
-            <summary>
-            Methods that extend known Unity objects and allow to directly create and control tweens from their instances.
-            These, as all DOTween46 methods, require Unity 4.6 or later.
-            </summary>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOFade(UnityEngine.CanvasGroup,System.Single,System.Single)">
-            <summary>Tweens a CanvasGroup's alpha color to the given value.
-            Also stores the canvasGroup as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOColor(UnityEngine.UI.Graphic,UnityEngine.Color,System.Single)">
-            <summary>Tweens an Graphic's color to the given value.
-            Also stores the image as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOFade(UnityEngine.UI.Graphic,System.Single,System.Single)">
-            <summary>Tweens an Graphic's alpha color to the given value.
-            Also stores the image as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOColor(UnityEngine.UI.Image,UnityEngine.Color,System.Single)">
-            <summary>Tweens an Image's color to the given value.
-            Also stores the image as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOFade(UnityEngine.UI.Image,System.Single,System.Single)">
-            <summary>Tweens an Image's alpha color to the given value.
-            Also stores the image as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOFillAmount(UnityEngine.UI.Image,System.Single,System.Single)">
-            <summary>Tweens an Image's fillAmount to the given value.
-            Also stores the image as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach (0 to 1)</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOGradientColor(UnityEngine.UI.Image,UnityEngine.Gradient,System.Single)">
-            <summary>Tweens an Image's colors using the given gradient
-            (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
-            Also stores the image as the tween's target so it can be used for filtered operations</summary>
-            <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOFlexibleSize(UnityEngine.UI.LayoutElement,UnityEngine.Vector2,System.Single,System.Boolean)">
-            <summary>Tweens an LayoutElement's flexibleWidth/Height to the given value.
-            Also stores the LayoutElement as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOMinSize(UnityEngine.UI.LayoutElement,UnityEngine.Vector2,System.Single,System.Boolean)">
-            <summary>Tweens an LayoutElement's minWidth/Height to the given value.
-            Also stores the LayoutElement as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOPreferredSize(UnityEngine.UI.LayoutElement,UnityEngine.Vector2,System.Single,System.Boolean)">
-            <summary>Tweens an LayoutElement's preferredWidth/Height to the given value.
-            Also stores the LayoutElement as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOColor(UnityEngine.UI.Outline,UnityEngine.Color,System.Single)">
-            <summary>Tweens a Outline's effectColor to the given value.
-            Also stores the Outline as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOFade(UnityEngine.UI.Outline,System.Single,System.Single)">
-            <summary>Tweens a Outline's effectColor alpha to the given value.
-            Also stores the Outline as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOScale(UnityEngine.UI.Outline,UnityEngine.Vector2,System.Single)">
-            <summary>Tweens a Outline's effectDistance to the given value.
-            Also stores the Outline as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOAnchorPos(UnityEngine.RectTransform,UnityEngine.Vector2,System.Single,System.Boolean)">
-            <summary>Tweens a RectTransform's anchoredPosition to the given value.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOAnchorPosX(UnityEngine.RectTransform,System.Single,System.Single,System.Boolean)">
-            <summary>Tweens a RectTransform's anchoredPosition X to the given value.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOAnchorPosY(UnityEngine.RectTransform,System.Single,System.Single,System.Boolean)">
-            <summary>Tweens a RectTransform's anchoredPosition Y to the given value.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOAnchorPos3D(UnityEngine.RectTransform,UnityEngine.Vector3,System.Single,System.Boolean)">
-            <summary>Tweens a RectTransform's anchoredPosition3D to the given value.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOAnchorMax(UnityEngine.RectTransform,UnityEngine.Vector2,System.Single,System.Boolean)">
-            <summary>Tweens a RectTransform's anchorMax to the given value.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOAnchorMin(UnityEngine.RectTransform,UnityEngine.Vector2,System.Single,System.Boolean)">
-            <summary>Tweens a RectTransform's anchorMin to the given value.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOPivot(UnityEngine.RectTransform,UnityEngine.Vector2,System.Single)">
-            <summary>Tweens a RectTransform's pivot to the given value.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOPivotX(UnityEngine.RectTransform,System.Single,System.Single)">
-            <summary>Tweens a RectTransform's pivot X to the given value.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOPivotY(UnityEngine.RectTransform,System.Single,System.Single)">
-            <summary>Tweens a RectTransform's pivot Y to the given value.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOSizeDelta(UnityEngine.RectTransform,UnityEngine.Vector2,System.Single,System.Boolean)">
-            <summary>Tweens a RectTransform's sizeDelta to the given value.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOPunchAnchorPos(UnityEngine.RectTransform,UnityEngine.Vector2,System.Single,System.Int32,System.Single,System.Boolean)">
-            <summary>Punches a RectTransform's anchoredPosition towards the given direction and then back to the starting one
-            as if it was connected to the starting position via an elastic.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="punch">The direction and strength of the punch (added to the RectTransform's current position)</param>
-            <param name="duration">The duration of the tween</param>
-            <param name="vibrato">Indicates how much will the punch vibrate</param>
-            <param name="elasticity">Represents how much (0 to 1) the vector will go beyond the starting position when bouncing backwards.
-            1 creates a full oscillation between the punch direction and the opposite direction,
-            while 0 oscillates only between the punch and the start position</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOShakeAnchorPos(UnityEngine.RectTransform,System.Single,System.Single,System.Int32,System.Single,System.Boolean,System.Boolean)">
-            <summary>Shakes a RectTransform's anchoredPosition with the given values.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="duration">The duration of the tween</param>
-            <param name="strength">The shake strength</param>
-            <param name="vibrato">Indicates how much will the shake vibrate</param>
-            <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). 
-            Setting it to 0 will shake along a single direction.</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-            <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOShakeAnchorPos(UnityEngine.RectTransform,System.Single,UnityEngine.Vector2,System.Int32,System.Single,System.Boolean,System.Boolean)">
-            <summary>Shakes a RectTransform's anchoredPosition with the given values.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="duration">The duration of the tween</param>
-            <param name="strength">The shake strength on each axis</param>
-            <param name="vibrato">Indicates how much will the shake vibrate</param>
-            <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). 
-            Setting it to 0 will shake along a single direction.</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-            <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOJumpAnchorPos(UnityEngine.RectTransform,UnityEngine.Vector2,System.Single,System.Int32,System.Single,System.Boolean)">
-            <summary>Tweens a RectTransform's anchoredPosition to the given value, while also applying a jump effect along the Y axis.
-            Returns a Sequence instead of a Tweener.
-            Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param>
-            <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
-            <param name="numJumps">Total number of jumps</param>
-            <param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DONormalizedPos(UnityEngine.UI.ScrollRect,UnityEngine.Vector2,System.Single,System.Boolean)">
-            <summary>Tweens a ScrollRect's horizontal/verticalNormalizedPosition to the given value.
-            Also stores the ScrollRect as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOHorizontalNormalizedPos(UnityEngine.UI.ScrollRect,System.Single,System.Single,System.Boolean)">
-            <summary>Tweens a ScrollRect's horizontalNormalizedPosition to the given value.
-            Also stores the ScrollRect as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOVerticalNormalizedPos(UnityEngine.UI.ScrollRect,System.Single,System.Single,System.Boolean)">
-            <summary>Tweens a ScrollRect's verticalNormalizedPosition to the given value.
-            Also stores the ScrollRect as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOValue(UnityEngine.UI.Slider,System.Single,System.Single,System.Boolean)">
-            <summary>Tweens a Slider's value to the given value.
-            Also stores the Slider as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-            <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOColor(UnityEngine.UI.Text,UnityEngine.Color,System.Single)">
-            <summary>Tweens a Text's color to the given value.
-            Also stores the Text as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOFade(UnityEngine.UI.Text,System.Single,System.Single)">
-            <summary>Tweens a Text's alpha color to the given value.
-            Also stores the Text as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOText(UnityEngine.UI.Text,System.String,System.Single,System.Boolean,DG.Tweening.ScrambleMode,System.String)">
-            <summary>Tweens a Text's text to the given value.
-            Also stores the Text as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param>
-            <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated,
-            otherwise all tags will be considered as normal text</param>
-            <param name="scrambleMode">The type of scramble mode to use, if any</param>
-            <param name="scrambleChars">A string containing the characters to use for scrambling.
-            Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters.
-            Leave it to NULL (default) to use default ones</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOBlendableColor(UnityEngine.UI.Graphic,UnityEngine.Color,System.Single)">
-            <summary>Tweens a Graphic's color to the given value,
-            in a way that allows other DOBlendableColor tweens to work together on the same target,
-            instead than fight each other as multiple DOColor would do.
-            Also stores the Graphic as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOBlendableColor(UnityEngine.UI.Image,UnityEngine.Color,System.Single)">
-            <summary>Tweens a Image's color to the given value,
-            in a way that allows other DOBlendableColor tweens to work together on the same target,
-            instead than fight each other as multiple DOColor would do.
-            Also stores the Image as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions46.DOBlendableColor(UnityEngine.UI.Text,UnityEngine.Color,System.Single)">
-            <summary>Tweens a Text's color BY the given value,
-            in a way that allows other DOBlendableColor tweens to work together on the same target,
-            instead than fight each other as multiple DOColor would do.
-            Also stores the Text as the tween's target so it can be used for filtered operations</summary>
-            <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
-        </member>
-    </members>
-</doc>

UnityExamples.Unity5/Assets/Demigiant/DOTween/DOTween46.xml.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 11b4db111ab0d92449c73aa232309358
-timeCreated: 1427036876
-licenseType: Pro
-TextScriptImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/DOTween50.dll.meta

@@ -1,24 +0,0 @@
-fileFormatVersion: 2
-guid: 244f321fc1b65154cb9485465856c92f
-timeCreated: 1427036875
-licenseType: Pro
-PluginImporter:
-  serializedVersion: 1
-  iconMap: {}
-  executionOrder: {}
-  isPreloaded: 0
-  platformData:
-    Any:
-      enabled: 1
-      settings: {}
-    Editor:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-    WindowsStoreApps:
-      enabled: 0
-      settings:
-        CPU: AnyCPU
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/DOTween50.xml

@@ -1,112 +0,0 @@
-<?xml version="1.0"?>
-<doc>
-    <assembly>
-        <name>DOTween50</name>
-    </assembly>
-    <members>
-        <member name="T:DG.Tweening.ShortcutExtensions50">
-            <summary>
-            Methods that extend known Unity objects and allow to directly create and control tweens from their instances.
-            These, as all DOTween50 methods, require Unity 5.0 or later.
-            </summary>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DOSetFloat(UnityEngine.Audio.AudioMixer,System.String,System.Single,System.Single)">
-            <summary>Tweens an AudioMixer's exposed float to the given value.
-            Also stores the AudioMixer as the tween's target so it can be used for filtered operations.
-            Note that you need to manually expose a float in an AudioMixerGroup in order to be able to tween it from an AudioMixer.</summary>
-            <param name="floatName">Name given to the exposed float to set</param>
-            <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DOComplete(UnityEngine.Audio.AudioMixer,System.Boolean)">
-            <summary>
-            Completes all tweens that have this target as a reference
-            (meaning tweens that were started from this target, or that had this target added as an Id)
-            and returns the total number of tweens completed
-            (meaning the tweens that don't have infinite loops and were not already complete)
-            </summary>
-            <param name="withCallbacks">For Sequences only: if TRUE also internal Sequence callbacks will be fired,
-            otherwise they will be ignored</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DOKill(UnityEngine.Audio.AudioMixer,System.Boolean)">
-            <summary>
-            Kills all tweens that have this target as a reference
-            (meaning tweens that were started from this target, or that had this target added as an Id)
-            and returns the total number of tweens killed.
-            </summary>
-            <param name="complete">If TRUE completes the tween before killing it</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DOFlip(UnityEngine.Audio.AudioMixer)">
-            <summary>
-            Flips the direction (backwards if it was going forward or viceversa) of all tweens that have this target as a reference
-            (meaning tweens that were started from this target, or that had this target added as an Id)
-            and returns the total number of tweens flipped.
-            </summary>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DOGoto(UnityEngine.Audio.AudioMixer,System.Single,System.Boolean)">
-            <summary>
-            Sends to the given position all tweens that have this target as a reference
-            (meaning tweens that were started from this target, or that had this target added as an Id)
-            and returns the total number of tweens involved.
-            </summary>
-            <param name="to">Time position to reach
-            (if higher than the whole tween duration the tween will simply reach its end)</param>
-            <param name="andPlay">If TRUE will play the tween after reaching the given position, otherwise it will pause it</param>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DOPause(UnityEngine.Audio.AudioMixer)">
-            <summary>
-            Pauses all tweens that have this target as a reference
-            (meaning tweens that were started from this target, or that had this target added as an Id)
-            and returns the total number of tweens paused.
-            </summary>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DOPlay(UnityEngine.Audio.AudioMixer)">
-            <summary>
-            Plays all tweens that have this target as a reference
-            (meaning tweens that were started from this target, or that had this target added as an Id)
-            and returns the total number of tweens played.
-            </summary>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DOPlayBackwards(UnityEngine.Audio.AudioMixer)">
-            <summary>
-            Plays backwards all tweens that have this target as a reference
-            (meaning tweens that were started from this target, or that had this target added as an Id)
-            and returns the total number of tweens played.
-            </summary>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DOPlayForward(UnityEngine.Audio.AudioMixer)">
-            <summary>
-            Plays forward all tweens that have this target as a reference
-            (meaning tweens that were started from this target, or that had this target added as an Id)
-            and returns the total number of tweens played.
-            </summary>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DORestart(UnityEngine.Audio.AudioMixer)">
-            <summary>
-            Restarts all tweens that have this target as a reference
-            (meaning tweens that were started from this target, or that had this target added as an Id)
-            and returns the total number of tweens restarted.
-            </summary>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DORewind(UnityEngine.Audio.AudioMixer)">
-            <summary>
-            Rewinds all tweens that have this target as a reference
-            (meaning tweens that were started from this target, or that had this target added as an Id)
-            and returns the total number of tweens rewinded.
-            </summary>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DOSmoothRewind(UnityEngine.Audio.AudioMixer)">
-            <summary>
-            Smoothly rewinds all tweens that have this target as a reference
-            (meaning tweens that were started from this target, or that had this target added as an Id)
-            and returns the total number of tweens rewinded.
-            </summary>
-        </member>
-        <member name="M:DG.Tweening.ShortcutExtensions50.DOTogglePause(UnityEngine.Audio.AudioMixer)">
-            <summary>
-            Toggles the paused state (plays if it was paused, pauses if it was playing) of all tweens that have this target as a reference
-            (meaning tweens that were started from this target, or that had this target added as an Id)
-            and returns the total number of tweens involved.
-            </summary>
-        </member>
-    </members>
-</doc>

UnityExamples.Unity5/Assets/Demigiant/DOTween/DOTween50.xml.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 77cae47a46077594587f7b82623ca74c
-timeCreated: 1427036876
-licenseType: Pro
-TextScriptImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/Editor/DOTweenEditor.XML

@@ -4,37 +4,58 @@
         <name>DOTweenEditor</name>
     </assembly>
     <members>
-        <member name="M:DG.DOTweenEditor.Core.EditorUtils.SetEditorTexture(UnityEngine.Texture2D,UnityEngine.FilterMode,System.Int32)">
+        <member name="M:DG.DOTweenEditor.DOTweenEditorPreview.Start(System.Action)">
+            <summary>
+            Starts the update loop of tween in the editor. Has no effect during playMode.
+            </summary>
+            <param name="onPreviewUpdated">Eventual callback to call after every update</param>
+        </member>
+        <member name="M:DG.DOTweenEditor.DOTweenEditorPreview.Stop(System.Boolean)">
+            <summary>
+            Stops the update loop and clears the onPreviewUpdated callback.
+            </summary>
+            <param name="resetTweenTargets">If TRUE also resets the tweened objects to their original state</param>
+        </member>
+        <member name="M:DG.DOTweenEditor.DOTweenEditorPreview.PrepareTweenForPreview(DG.Tweening.Tween,System.Boolean,System.Boolean,System.Boolean)">
+            <summary>
+            Readies the tween for editor preview by setting its UpdateType to Manual plus eventual extra settings.
+            </summary>
+            <param name="t">The tween to ready</param>
+            <param name="clearCallbacks">If TRUE (recommended) removes all callbacks (OnComplete/Rewind/etc)</param>
+            <param name="preventAutoKill">If TRUE prevents the tween from being auto-killed at completion</param>
+            <param name="andPlay">If TRUE starts playing the tween immediately</param>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.SetEditorTexture(UnityEngine.Texture2D,UnityEngine.FilterMode,System.Int32)">
             <summary>
             Checks that the given editor texture use the correct import settings,
             and applies them if they're incorrect.
             </summary>
         </member>
-        <member name="M:DG.DOTweenEditor.Core.EditorUtils.DOTweenSetupRequired">
+        <member name="M:DG.DOTweenEditor.EditorUtils.DOTweenSetupRequired">
             <summary>
-            Returns TRUE if addons setup is required.
+            Returns TRUE if setup is required
             </summary>
         </member>
-        <member name="M:DG.DOTweenEditor.Core.EditorUtils.AssetExists(System.String)">
+        <member name="M:DG.DOTweenEditor.EditorUtils.AssetExists(System.String)">
             <summary>
             Returns TRUE if the file/directory at the given path exists.
             </summary>
             <param name="adbPath">Path, relative to Unity's project folder</param>
             <returns></returns>
         </member>
-        <member name="M:DG.DOTweenEditor.Core.EditorUtils.ADBPathToFullPath(System.String)">
+        <member name="M:DG.DOTweenEditor.EditorUtils.ADBPathToFullPath(System.String)">
             <summary>
             Converts the given project-relative path to a full path,
             with backward (\) slashes).
             </summary>
         </member>
-        <member name="M:DG.DOTweenEditor.Core.EditorUtils.FullPathToADBPath(System.String)">
+        <member name="M:DG.DOTweenEditor.EditorUtils.FullPathToADBPath(System.String)">
             <summary>
             Converts the given full path to a path usable with AssetDatabase methods
             (relative to Unity's project folder, and with the correct Unity forward (/) slashes).
             </summary>
         </member>
-        <member name="M:DG.DOTweenEditor.Core.EditorUtils.ConnectToSourceAsset``1(System.String,System.Boolean)">
+        <member name="M:DG.DOTweenEditor.EditorUtils.ConnectToSourceAsset``1(System.String,System.Boolean)">
             <summary>
             Connects to a <see cref="T:UnityEngine.ScriptableObject"/> asset.
             If the asset already exists at the given path, loads it and returns it.
@@ -45,21 +66,33 @@
             <param name="adbFilePath">File path (relative to Unity's project folder)</param>
             <param name="createIfMissing">If TRUE and the requested asset doesn't exist, forces its creation</param>
         </member>
-        <member name="M:DG.DOTweenEditor.Core.EditorUtils.GetAssemblyFilePath(System.Reflection.Assembly)">
+        <member name="M:DG.DOTweenEditor.EditorUtils.GetAssemblyFilePath(System.Reflection.Assembly)">
             <summary>
             Full path for the given loaded assembly, assembly file included
             </summary>
         </member>
-        <member name="T:DG.DOTweenEditor.DOTweenSetupMenuItem">
+        <member name="M:DG.DOTweenEditor.EditorUtils.AddGlobalDefine(System.String)">
+            <summary>
+            Adds the given global define if it's not already present
+            </summary>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.RemoveGlobalDefine(System.String)">
+            <summary>
+            Removes the given global define if it's present
+            </summary>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.HasGlobalDefine(System.String,System.Nullable{UnityEditor.BuildTargetGroup})">
+            <summary>
+            Returns TRUE if the given global define is present in all the <see cref="T:UnityEditor.BuildTargetGroup"/>
+            or only in the given <see cref="T:UnityEditor.BuildTargetGroup"/>, depending on passed parameters.<para/>
+            </summary>
+            <param name="id"></param>
+            <param name="buildTargetGroup"><see cref="T:UnityEditor.BuildTargetGroup"/>to use. Leave NULL to check in all of them.</param>
+        </member>
+        <member name="T:DG.DOTweenEditor.DOTweenDefines">
             <summary>
             Not used as menu item anymore, but as a utiity function
             </summary>
         </member>
-        <member name="M:DG.DOTweenEditor.DOTweenSetupMenuItem.Setup(System.Boolean)">
-            <summary>
-            Setups DOTween
-            </summary>
-            <param name="partiallySilent">If TRUE, no warning window appears in case there is no need for setup</param>
-        </member>
     </members>
 </doc>

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules.meta

@@ -1,6 +1,7 @@
 fileFormatVersion: 2
-guid: 305308bb99989414fa15ec8e339b70b0
+guid: a8aaba8675a8ddc41b00c35c85e249a8
-timeCreated: 1427036874
+folderAsset: yes
+timeCreated: 1571306499
 licenseType: Pro
 DefaultImporter:
   userData: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs

@@ -0,0 +1,202 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+#if true // MODULE_MARKER
+using System;
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Options;
+using UnityEngine;
+#if UNITY_5 || UNITY_2017_1_OR_NEWER
+using UnityEngine.Audio; // Required for AudioMixer
+#endif
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+	public static class DOTweenModuleAudio
+    {
+        #region Shortcuts
+
+        #region Audio
+
+        /// <summary>Tweens an AudioSource's volume to the given value.
+        /// Also stores the AudioSource as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach (0 to 1)</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DOFade(this AudioSource target, float endValue, float duration)
+        {
+            if (endValue < 0) endValue = 0;
+            else if (endValue > 1) endValue = 1;
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.volume, x => target.volume = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an AudioSource's pitch to the given value.
+        /// Also stores the AudioSource as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DOPitch(this AudioSource target, float endValue, float duration)
+        {
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.pitch, x => target.pitch = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+#if UNITY_5 || UNITY_2017_1_OR_NEWER
+        #region AudioMixer (Unity 5 or Newer)
+
+        /// <summary>Tweens an AudioMixer's exposed float to the given value.
+        /// Also stores the AudioMixer as the tween's target so it can be used for filtered operations.
+        /// Note that you need to manually expose a float in an AudioMixerGroup in order to be able to tween it from an AudioMixer.</summary>
+        /// <param name="floatName">Name given to the exposed float to set</param>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DOSetFloat(this AudioMixer target, string floatName, float endValue, float duration)
+        {
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(()=> {
+                    float currVal;
+                    target.GetFloat(floatName, out currVal);
+                    return currVal;
+                }, x=> target.SetFloat(floatName, x), endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #region Operation Shortcuts
+
+        /// <summary>
+        /// Completes all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens completed
+        /// (meaning the tweens that don't have infinite loops and were not already complete)
+        /// </summary>
+        /// <param name="withCallbacks">For Sequences only: if TRUE also internal Sequence callbacks will be fired,
+        /// otherwise they will be ignored</param>
+        public static int DOComplete(this AudioMixer target, bool withCallbacks = false)
+        {
+            return DOTween.Complete(target, withCallbacks);
+        }
+
+        /// <summary>
+        /// Kills all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens killed.
+        /// </summary>
+        /// <param name="complete">If TRUE completes the tween before killing it</param>
+        public static int DOKill(this AudioMixer target, bool complete = false)
+        {
+            return DOTween.Kill(target, complete);
+        }
+
+        /// <summary>
+        /// Flips the direction (backwards if it was going forward or viceversa) of all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens flipped.
+        /// </summary>
+        public static int DOFlip(this AudioMixer target)
+        {
+            return DOTween.Flip(target);
+        }
+
+        /// <summary>
+        /// Sends to the given position all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens involved.
+        /// </summary>
+        /// <param name="to">Time position to reach
+        /// (if higher than the whole tween duration the tween will simply reach its end)</param>
+        /// <param name="andPlay">If TRUE will play the tween after reaching the given position, otherwise it will pause it</param>
+        public static int DOGoto(this AudioMixer target, float to, bool andPlay = false)
+        {
+            return DOTween.Goto(target, to, andPlay);
+        }
+
+        /// <summary>
+        /// Pauses all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens paused.
+        /// </summary>
+        public static int DOPause(this AudioMixer target)
+        {
+            return DOTween.Pause(target);
+        }
+
+        /// <summary>
+        /// Plays all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens played.
+        /// </summary>
+        public static int DOPlay(this AudioMixer target)
+        {
+            return DOTween.Play(target);
+        }
+
+        /// <summary>
+        /// Plays backwards all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens played.
+        /// </summary>
+        public static int DOPlayBackwards(this AudioMixer target)
+        {
+            return DOTween.PlayBackwards(target);
+        }
+
+        /// <summary>
+        /// Plays forward all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens played.
+        /// </summary>
+        public static int DOPlayForward(this AudioMixer target)
+        {
+            return DOTween.PlayForward(target);
+        }
+
+        /// <summary>
+        /// Restarts all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens restarted.
+        /// </summary>
+        public static int DORestart(this AudioMixer target)
+        {
+            return DOTween.Restart(target);
+        }
+
+        /// <summary>
+        /// Rewinds all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens rewinded.
+        /// </summary>
+        public static int DORewind(this AudioMixer target)
+        {
+            return DOTween.Rewind(target);
+        }
+
+        /// <summary>
+        /// Smoothly rewinds all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens rewinded.
+        /// </summary>
+        public static int DOSmoothRewind(this AudioMixer target)
+        {
+            return DOTween.SmoothRewind(target);
+        }
+
+        /// <summary>
+        /// Toggles the paused state (plays if it was paused, pauses if it was playing) of all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens involved.
+        /// </summary>
+        public static int DOTogglePause(this AudioMixer target)
+        {
+            return DOTween.TogglePause(target);
+        }
+
+        #endregion
+
+        #endregion
+#endif
+
+        #endregion
+    }
+}
+#endif

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 35cdca364a187914bb323f7087eade56
+timeCreated: 1571306506
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs

@@ -0,0 +1,216 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+#if true // MODULE_MARKER
+using System;
+using DG.Tweening.Core;
+using DG.Tweening.Core.Enums;
+using DG.Tweening.Plugins;
+using DG.Tweening.Plugins.Core.PathCore;
+using DG.Tweening.Plugins.Options;
+using UnityEngine;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+	public static class DOTweenModulePhysics
+    {
+        #region Shortcuts
+
+        #region Rigidbody
+
+        /// <summary>Tweens a Rigidbody's position to the given value.
+        /// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOMove(this Rigidbody target, Vector3 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody's X position to the given value.
+        /// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOMoveX(this Rigidbody target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue, 0, 0), duration);
+            t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody's Y position to the given value.
+        /// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOMoveY(this Rigidbody target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, endValue, 0), duration);
+            t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody's Z position to the given value.
+        /// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOMoveZ(this Rigidbody target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, 0, endValue), duration);
+            t.SetOptions(AxisConstraint.Z, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody's rotation to the given value.
+        /// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="mode">Rotation mode</param>
+        public static TweenerCore<Quaternion, Vector3, QuaternionOptions> DORotate(this Rigidbody target, Vector3 endValue, float duration, RotateMode mode = RotateMode.Fast)
+        {
+            TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration);
+            t.SetTarget(target);
+            t.plugOptions.rotateMode = mode;
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody's rotation so that it will look towards the given position.
+        /// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="towards">The position to look at</param><param name="duration">The duration of the tween</param>
+        /// <param name="axisConstraint">Eventual axis constraint for the rotation</param>
+        /// <param name="up">The vector that defines in which direction up is (default: Vector3.up)</param>
+        public static TweenerCore<Quaternion, Vector3, QuaternionOptions> DOLookAt(this Rigidbody target, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3? up = null)
+        {
+            TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, towards, duration)
+                .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetLookAt);
+            t.plugOptions.axisConstraint = axisConstraint;
+            t.plugOptions.up = (up == null) ? Vector3.up : (Vector3)up;
+            return t;
+        }
+
+        #region Special
+
+        /// <summary>Tweens a Rigidbody's position to the given value, while also applying a jump effect along the Y axis.
+        /// Returns a Sequence instead of a Tweener.
+        /// Also stores the Rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
+        /// <param name="numJumps">Total number of jumps</param>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Sequence DOJump(this Rigidbody target, Vector3 endValue, float jumpPower, int numJumps, float duration, bool snapping = false)
+        {
+            if (numJumps < 1) numJumps = 1;
+            float startPosY = 0;
+            float offsetY = -1;
+            bool offsetYSet = false;
+            Sequence s = DOTween.Sequence();
+            Tween yTween = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, jumpPower, 0), duration / (numJumps * 2))
+                .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative()
+                .SetLoops(numJumps * 2, LoopType.Yoyo)
+                .OnStart(() => startPosY = target.position.y);
+            s.Append(DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue.x, 0, 0), duration)
+                    .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
+                ).Join(DOTween.To(() => target.position, target.MovePosition, new Vector3(0, 0, endValue.z), duration)
+                    .SetOptions(AxisConstraint.Z, snapping).SetEase(Ease.Linear)
+                ).Join(yTween)
+                .SetTarget(target).SetEase(DOTween.defaultEaseType);
+            yTween.OnUpdate(() => {
+                if (!offsetYSet) {
+                    offsetYSet = true;
+                    offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
+                }
+                Vector3 pos = target.position;
+                pos.y += DOVirtual.EasedValue(0, offsetY, yTween.ElapsedPercentage(), Ease.OutQuad);
+                target.MovePosition(pos);
+            });
+            return s;
+        }
+
+        /// <summary>Tweens a Rigidbody's position through the given path waypoints, using the chosen path algorithm.
+        /// Also stores the Rigidbody as the tween's target so it can be used for filtered operations.
+        /// <para>NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened.</para>
+        /// <para>BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
+        /// If you plan to publish there you should use a regular transform.DOPath.</para></summary>
+        /// <param name="path">The waypoints to go through</param>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="pathType">The type of path: Linear (straight path) or CatmullRom (curved CatmullRom path)</param>
+        /// <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
+        /// <param name="resolution">The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved paths but are more expensive.
+        /// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
+        /// <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
+        public static TweenerCore<Vector3, Path, PathOptions> DOPath(
+            this Rigidbody target, Vector3[] path, float duration, PathType pathType = PathType.Linear,
+            PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null
+        )
+        {
+            if (resolution < 1) resolution = 1;
+            TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => target.position, target.MovePosition, new Path(pathType, path, resolution, gizmoColor), duration)
+                .SetTarget(target).SetUpdate(UpdateType.Fixed);
+
+            t.plugOptions.isRigidbody = true;
+            t.plugOptions.mode = pathMode;
+            return t;
+        }
+        /// <summary>Tweens a Rigidbody's localPosition through the given path waypoints, using the chosen path algorithm.
+        /// Also stores the Rigidbody as the tween's target so it can be used for filtered operations
+        /// <para>NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened.</para>
+        /// <para>BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
+        /// If you plan to publish there you should use a regular transform.DOLocalPath.</para></summary>
+        /// <param name="path">The waypoint to go through</param>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="pathType">The type of path: Linear (straight path) or CatmullRom (curved CatmullRom path)</param>
+        /// <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
+        /// <param name="resolution">The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive.
+        /// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
+        /// <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
+        public static TweenerCore<Vector3, Path, PathOptions> DOLocalPath(
+            this Rigidbody target, Vector3[] path, float duration, PathType pathType = PathType.Linear,
+            PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null
+        )
+        {
+            if (resolution < 1) resolution = 1;
+            Transform trans = target.transform;
+            TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), new Path(pathType, path, resolution, gizmoColor), duration)
+                .SetTarget(target).SetUpdate(UpdateType.Fixed);
+
+            t.plugOptions.isRigidbody = true;
+            t.plugOptions.mode = pathMode;
+            t.plugOptions.useLocalPosition = true;
+            return t;
+        }
+        // Used by path editor when creating the actual tween, so it can pass a pre-compiled path
+        internal static TweenerCore<Vector3, Path, PathOptions> DOPath(
+            this Rigidbody target, Path path, float duration, PathMode pathMode = PathMode.Full3D
+        )
+        {
+            TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => target.position, target.MovePosition, path, duration)
+                .SetTarget(target);
+
+            t.plugOptions.isRigidbody = true;
+            t.plugOptions.mode = pathMode;
+            return t;
+        }
+        internal static TweenerCore<Vector3, Path, PathOptions> DOLocalPath(
+            this Rigidbody target, Path path, float duration, PathMode pathMode = PathMode.Full3D
+        )
+        {
+            Transform trans = target.transform;
+            TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), path, duration)
+                .SetTarget(target);
+
+            t.plugOptions.isRigidbody = true;
+            t.plugOptions.mode = pathMode;
+            t.plugOptions.useLocalPosition = true;
+            return t;
+        }
+
+        #endregion
+
+        #endregion
+
+        #endregion
+	}
+}
+#endif

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a2c8eb01e28f57043873d9e80957dcb2
+timeCreated: 1571306506
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs

@@ -0,0 +1,107 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+#if true && (UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1_OR_NEWER) // MODULE_MARKER
+using System;
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Options;
+using UnityEngine;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+	public static class DOTweenModulePhysics2D
+    {
+        #region Shortcuts
+
+        #region Rigidbody2D Shortcuts
+
+        /// <summary>Tweens a Rigidbody2D's position to the given value.
+        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMove(this Rigidbody2D target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody2D's X position to the given value.
+        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMoveX(this Rigidbody2D target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector2(endValue, 0), duration);
+            t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody2D's Y position to the given value.
+        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMoveY(this Rigidbody2D target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector2(0, endValue), duration);
+            t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody2D's rotation to the given value.
+        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DORotate(this Rigidbody2D target, float endValue, float duration)
+        {
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #region Special
+
+        /// <summary>Tweens a Rigidbody2D's position to the given value, while also applying a jump effect along the Y axis.
+        /// Returns a Sequence instead of a Tweener.
+        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations.
+        /// <para>IMPORTANT: a rigidbody2D can't be animated in a jump arc using MovePosition, so the tween will directly set the position</para></summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
+        /// <param name="numJumps">Total number of jumps</param>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Sequence DOJump(this Rigidbody2D target, Vector2 endValue, float jumpPower, int numJumps, float duration, bool snapping = false)
+        {
+            if (numJumps < 1) numJumps = 1;
+            float startPosY = 0;
+            float offsetY = -1;
+            bool offsetYSet = false;
+            Sequence s = DOTween.Sequence();
+            Tween yTween = DOTween.To(() => target.position, x => target.position = x, new Vector2(0, jumpPower), duration / (numJumps * 2))
+                .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative()
+                .SetLoops(numJumps * 2, LoopType.Yoyo)
+                .OnStart(() => startPosY = target.position.y);
+            s.Append(DOTween.To(() => target.position, x => target.position = x, new Vector2(endValue.x, 0), duration)
+                    .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
+                ).Join(yTween)
+                .SetTarget(target).SetEase(DOTween.defaultEaseType);
+            yTween.OnUpdate(() => {
+                if (!offsetYSet) {
+                    offsetYSet = true;
+                    offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
+                }
+                Vector3 pos = target.position;
+                pos.y += DOVirtual.EasedValue(0, offsetY, yTween.ElapsedPercentage(), Ease.OutQuad);
+                target.MovePosition(pos);
+            });
+            return s;
+        }
+
+        #endregion
+
+        #endregion
+
+        #endregion
+	}
+}
+#endif

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e5f6736898055da4a92c520f0e872cc4
+timeCreated: 1571306506
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs

@@ -0,0 +1,93 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+#if true && (UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1_OR_NEWER) // MODULE_MARKER
+using System;
+using UnityEngine;
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Options;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+	public static class DOTweenModuleSprite
+    {
+        #region Shortcuts
+
+        #region SpriteRenderer
+
+        /// <summary>Tweens a SpriteRenderer's color to the given value.
+        /// Also stores the spriteRenderer as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this SpriteRenderer target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Material's alpha color to the given value.
+        /// Also stores the spriteRenderer as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this SpriteRenderer target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a SpriteRenderer's color using the given gradient
+        /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
+        public static Sequence DOGradientColor(this SpriteRenderer target, Gradient gradient, float duration)
+        {
+            Sequence s = DOTween.Sequence();
+            GradientColorKey[] colors = gradient.colorKeys;
+            int len = colors.Length;
+            for (int i = 0; i < len; ++i) {
+                GradientColorKey c = colors[i];
+                if (i == 0 && c.time <= 0) {
+                    target.color = c.color;
+                    continue;
+                }
+                float colorDuration = i == len - 1
+                    ? duration - s.Duration(false) // Verifies that total duration is correct
+                    : duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
+                s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
+            }
+            s.SetTarget(target);
+            return s;
+        }
+
+        #endregion
+
+        #region Blendables
+
+        #region SpriteRenderer
+
+        /// <summary>Tweens a SpriteRenderer's color to the given value,
+        /// in a way that allows other DOBlendableColor tweens to work together on the same target,
+        /// instead than fight each other as multiple DOColor would do.
+        /// Also stores the SpriteRenderer as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
+        public static Tweener DOBlendableColor(this SpriteRenderer target, Color endValue, float duration)
+        {
+            endValue = endValue - target.color;
+            Color to = new Color(0, 0, 0, 0);
+            return DOTween.To(() => to, x => {
+                    Color diff = x - to;
+                    to = x;
+                    target.color += diff;
+                }, endValue, duration)
+                .Blendable().SetTarget(target);
+        }
+
+        #endregion
+
+        #endregion
+
+        #endregion
+	}
+}
+#endif

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f5b5b3a415279844d88ddc9f4d926c68
+timeCreated: 1571306506
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModuleUI.cs

@@ -0,0 +1,609 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+#if true && (UNITY_4_6 || UNITY_5 || UNITY_2017_1_OR_NEWER) // MODULE_MARKER
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using DG.Tweening.Core;
+using DG.Tweening.Core.Enums;
+using DG.Tweening.Plugins.Options;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+	public static class DOTweenModuleUI
+    {
+        #region Shortcuts
+
+        #region CanvasGroup
+
+        /// <summary>Tweens a CanvasGroup's alpha color to the given value.
+        /// Also stores the canvasGroup as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DOFade(this CanvasGroup target, float endValue, float duration)
+        {
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.alpha, x => target.alpha = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region Graphic
+
+        /// <summary>Tweens an Graphic's color to the given value.
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this Graphic target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an Graphic's alpha color to the given value.
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this Graphic target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region Image
+
+        /// <summary>Tweens an Image's color to the given value.
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this Image target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an Image's alpha color to the given value.
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this Image target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an Image's fillAmount to the given value.
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach (0 to 1)</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DOFillAmount(this Image target, float endValue, float duration)
+        {
+            if (endValue > 1) endValue = 1;
+            else if (endValue < 0) endValue = 0;
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.fillAmount, x => target.fillAmount = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an Image's colors using the given gradient
+        /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
+        public static Sequence DOGradientColor(this Image target, Gradient gradient, float duration)
+        {
+            Sequence s = DOTween.Sequence();
+            GradientColorKey[] colors = gradient.colorKeys;
+            int len = colors.Length;
+            for (int i = 0; i < len; ++i) {
+                GradientColorKey c = colors[i];
+                if (i == 0 && c.time <= 0) {
+                    target.color = c.color;
+                    continue;
+                }
+                float colorDuration = i == len - 1
+                    ? duration - s.Duration(false) // Verifies that total duration is correct
+                    : duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
+                s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
+            }
+            s.SetTarget(target);
+            return s;
+        }
+
+        #endregion
+
+        #region LayoutElement
+
+        /// <summary>Tweens an LayoutElement's flexibleWidth/Height to the given value.
+        /// Also stores the LayoutElement as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOFlexibleSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => new Vector2(target.flexibleWidth, target.flexibleHeight), x => {
+                    target.flexibleWidth = x.x;
+                    target.flexibleHeight = x.y;
+                }, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an LayoutElement's minWidth/Height to the given value.
+        /// Also stores the LayoutElement as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMinSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => new Vector2(target.minWidth, target.minHeight), x => {
+                target.minWidth = x.x;
+                target.minHeight = x.y;
+            }, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an LayoutElement's preferredWidth/Height to the given value.
+        /// Also stores the LayoutElement as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOPreferredSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => new Vector2(target.preferredWidth, target.preferredHeight), x => {
+                target.preferredWidth = x.x;
+                target.preferredHeight = x.y;
+            }, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region Outline
+
+        /// <summary>Tweens a Outline's effectColor to the given value.
+        /// Also stores the Outline as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this Outline target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.effectColor, x => target.effectColor = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Outline's effectColor alpha to the given value.
+        /// Also stores the Outline as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this Outline target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.effectColor, x => target.effectColor = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Outline's effectDistance to the given value.
+        /// Also stores the Outline as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOScale(this Outline target, Vector2 endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.effectDistance, x => target.effectDistance = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region RectTransform
+
+        /// <summary>Tweens a RectTransform's anchoredPosition to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorPos(this RectTransform target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's anchoredPosition X to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorPosX(this RectTransform target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(endValue, 0), duration);
+            t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's anchoredPosition Y to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorPosY(this RectTransform target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(0, endValue), duration);
+            t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a RectTransform's anchoredPosition3D to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOAnchorPos3D(this RectTransform target, Vector3 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's anchoredPosition3D X to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOAnchorPos3DX(this RectTransform target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(endValue, 0, 0), duration);
+            t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's anchoredPosition3D Y to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOAnchorPos3DY(this RectTransform target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(0, endValue, 0), duration);
+            t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's anchoredPosition3D Z to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOAnchorPos3DZ(this RectTransform target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(0, 0, endValue), duration);
+            t.SetOptions(AxisConstraint.Z, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a RectTransform's anchorMax to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorMax(this RectTransform target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchorMax, x => target.anchorMax = x, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a RectTransform's anchorMin to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorMin(this RectTransform target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchorMin, x => target.anchorMin = x, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a RectTransform's pivot to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOPivot(this RectTransform target, Vector2 endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.pivot, x => target.pivot = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's pivot X to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOPivotX(this RectTransform target, float endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.pivot, x => target.pivot = x, new Vector2(endValue, 0), duration);
+            t.SetOptions(AxisConstraint.X).SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's pivot Y to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOPivotY(this RectTransform target, float endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.pivot, x => target.pivot = x, new Vector2(0, endValue), duration);
+            t.SetOptions(AxisConstraint.Y).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a RectTransform's sizeDelta to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOSizeDelta(this RectTransform target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.sizeDelta, x => target.sizeDelta = x, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Punches a RectTransform's anchoredPosition towards the given direction and then back to the starting one
+        /// as if it was connected to the starting position via an elastic.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="punch">The direction and strength of the punch (added to the RectTransform's current position)</param>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="vibrato">Indicates how much will the punch vibrate</param>
+        /// <param name="elasticity">Represents how much (0 to 1) the vector will go beyond the starting position when bouncing backwards.
+        /// 1 creates a full oscillation between the punch direction and the opposite direction,
+        /// while 0 oscillates only between the punch and the start position</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Tweener DOPunchAnchorPos(this RectTransform target, Vector2 punch, float duration, int vibrato = 10, float elasticity = 1, bool snapping = false)
+        {
+            return DOTween.Punch(() => target.anchoredPosition, x => target.anchoredPosition = x, punch, duration, vibrato, elasticity)
+                .SetTarget(target).SetOptions(snapping);
+        }
+
+        /// <summary>Shakes a RectTransform's anchoredPosition with the given values.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="strength">The shake strength</param>
+        /// <param name="vibrato">Indicates how much will the shake vibrate</param>
+        /// <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). 
+        /// Setting it to 0 will shake along a single direction.</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        /// <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
+        public static Tweener DOShakeAnchorPos(this RectTransform target, float duration, float strength = 100, int vibrato = 10, float randomness = 90, bool snapping = false, bool fadeOut = true)
+        {
+            return DOTween.Shake(() => target.anchoredPosition, x => target.anchoredPosition = x, duration, strength, vibrato, randomness, true, fadeOut)
+                .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetShake).SetOptions(snapping);
+        }
+        /// <summary>Shakes a RectTransform's anchoredPosition with the given values.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="strength">The shake strength on each axis</param>
+        /// <param name="vibrato">Indicates how much will the shake vibrate</param>
+        /// <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). 
+        /// Setting it to 0 will shake along a single direction.</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        /// <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
+        public static Tweener DOShakeAnchorPos(this RectTransform target, float duration, Vector2 strength, int vibrato = 10, float randomness = 90, bool snapping = false, bool fadeOut = true)
+        {
+            return DOTween.Shake(() => target.anchoredPosition, x => target.anchoredPosition = x, duration, strength, vibrato, randomness, fadeOut)
+                .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetShake).SetOptions(snapping);
+        }
+
+        #region Special
+
+        /// <summary>Tweens a RectTransform's anchoredPosition to the given value, while also applying a jump effect along the Y axis.
+        /// Returns a Sequence instead of a Tweener.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
+        /// <param name="numJumps">Total number of jumps</param>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Sequence DOJumpAnchorPos(this RectTransform target, Vector2 endValue, float jumpPower, int numJumps, float duration, bool snapping = false)
+        {
+            if (numJumps < 1) numJumps = 1;
+            float startPosY = 0;
+            float offsetY = -1;
+            bool offsetYSet = false;
+
+            // Separate Y Tween so we can elaborate elapsedPercentage on that insted of on the Sequence
+            // (in case users add a delay or other elements to the Sequence)
+            Sequence s = DOTween.Sequence();
+            Tween yTween = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(0, jumpPower), duration / (numJumps * 2))
+                .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative()
+                .SetLoops(numJumps * 2, LoopType.Yoyo)
+                .OnStart(()=> startPosY = target.anchoredPosition.y);
+            s.Append(DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(endValue.x, 0), duration)
+                    .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
+                ).Join(yTween)
+                .SetTarget(target).SetEase(DOTween.defaultEaseType);
+            s.OnUpdate(() => {
+                if (!offsetYSet) {
+                    offsetYSet = true;
+                    offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
+                }
+                Vector2 pos = target.anchoredPosition;
+                pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad);
+                target.anchoredPosition = pos;
+            });
+            return s;
+        }
+
+        #endregion
+
+        #endregion
+
+        #region ScrollRect
+
+        /// <summary>Tweens a ScrollRect's horizontal/verticalNormalizedPosition to the given value.
+        /// Also stores the ScrollRect as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Tweener DONormalizedPos(this ScrollRect target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            return DOTween.To(() => new Vector2(target.horizontalNormalizedPosition, target.verticalNormalizedPosition),
+                x => {
+                    target.horizontalNormalizedPosition = x.x;
+                    target.verticalNormalizedPosition = x.y;
+                }, endValue, duration)
+                .SetOptions(snapping).SetTarget(target);
+        }
+        /// <summary>Tweens a ScrollRect's horizontalNormalizedPosition to the given value.
+        /// Also stores the ScrollRect as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Tweener DOHorizontalNormalizedPos(this ScrollRect target, float endValue, float duration, bool snapping = false)
+        {
+            return DOTween.To(() => target.horizontalNormalizedPosition, x => target.horizontalNormalizedPosition = x, endValue, duration)
+                .SetOptions(snapping).SetTarget(target);
+        }
+        /// <summary>Tweens a ScrollRect's verticalNormalizedPosition to the given value.
+        /// Also stores the ScrollRect as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Tweener DOVerticalNormalizedPos(this ScrollRect target, float endValue, float duration, bool snapping = false)
+        {
+            return DOTween.To(() => target.verticalNormalizedPosition, x => target.verticalNormalizedPosition = x, endValue, duration)
+                .SetOptions(snapping).SetTarget(target);
+        }
+
+        #endregion
+
+        #region Slider
+
+        /// <summary>Tweens a Slider's value to the given value.
+        /// Also stores the Slider as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<float, float, FloatOptions> DOValue(this Slider target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.value, x => target.value = x, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region Text
+
+        /// <summary>Tweens a Text's color to the given value.
+        /// Also stores the Text as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this Text target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Text's alpha color to the given value.
+        /// Also stores the Text as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this Text target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Text's text to the given value.
+        /// Also stores the Text as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param>
+        /// <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated,
+        /// otherwise all tags will be considered as normal text</param>
+        /// <param name="scrambleMode">The type of scramble mode to use, if any</param>
+        /// <param name="scrambleChars">A string containing the characters to use for scrambling.
+        /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters.
+        /// Leave it to NULL (default) to use default ones</param>
+        public static TweenerCore<string, string, StringOptions> DOText(this Text target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null)
+        {
+            if (endValue == null) {
+                if (Debugger.logPriority > 0) Debugger.LogWarning("You can't pass a NULL string to DOText: an empty string will be used instead to avoid errors");
+                endValue = "";
+            }
+            TweenerCore<string, string, StringOptions> t = DOTween.To(() => target.text, x => target.text = x, endValue, duration);
+            t.SetOptions(richTextEnabled, scrambleMode, scrambleChars)
+                .SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region Blendables
+
+        #region Graphic
+
+        /// <summary>Tweens a Graphic's color to the given value,
+        /// in a way that allows other DOBlendableColor tweens to work together on the same target,
+        /// instead than fight each other as multiple DOColor would do.
+        /// Also stores the Graphic as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
+        public static Tweener DOBlendableColor(this Graphic target, Color endValue, float duration)
+        {
+            endValue = endValue - target.color;
+            Color to = new Color(0, 0, 0, 0);
+            return DOTween.To(() => to, x => {
+                Color diff = x - to;
+                to = x;
+                target.color += diff;
+            }, endValue, duration)
+                .Blendable().SetTarget(target);
+        }
+
+        #endregion
+
+        #region Image
+
+        /// <summary>Tweens a Image's color to the given value,
+        /// in a way that allows other DOBlendableColor tweens to work together on the same target,
+        /// instead than fight each other as multiple DOColor would do.
+        /// Also stores the Image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
+        public static Tweener DOBlendableColor(this Image target, Color endValue, float duration)
+        {
+            endValue = endValue - target.color;
+            Color to = new Color(0, 0, 0, 0);
+            return DOTween.To(() => to, x => {
+                Color diff = x - to;
+                to = x;
+                target.color += diff;
+            }, endValue, duration)
+                .Blendable().SetTarget(target);
+        }
+
+        #endregion
+
+        #region Text
+
+        /// <summary>Tweens a Text's color BY the given value,
+        /// in a way that allows other DOBlendableColor tweens to work together on the same target,
+        /// instead than fight each other as multiple DOColor would do.
+        /// Also stores the Text as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
+        public static Tweener DOBlendableColor(this Text target, Color endValue, float duration)
+        {
+            endValue = endValue - target.color;
+            Color to = new Color(0, 0, 0, 0);
+            return DOTween.To(() => to, x => {
+                Color diff = x - to;
+                to = x;
+                target.color += diff;
+            }, endValue, duration)
+                .Blendable().SetTarget(target);
+        }
+
+        #endregion
+
+        #endregion
+
+        #endregion
+
+        // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+        // ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████
+        // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+
+        public static class Utils
+        {
+            /// <summary>
+            /// Converts the anchoredPosition of the first RectTransform to the second RectTransform,
+            /// taking into consideration offset, anchors and pivot, and returns the new anchoredPosition
+            /// </summary>
+            public static Vector2 SwitchToRectTransform(RectTransform from, RectTransform to)
+            {
+                Vector2 localPoint;
+                Vector2 fromPivotDerivedOffset = new Vector2(from.rect.width * 0.5f + from.rect.xMin, from.rect.height * 0.5f + from.rect.yMin);
+                Vector2 screenP = RectTransformUtility.WorldToScreenPoint(null, from.position);
+                screenP += fromPivotDerivedOffset;
+                RectTransformUtility.ScreenPointToLocalPointInRectangle(to, screenP, null, out localPoint);
+                Vector2 pivotDerivedOffset = new Vector2(to.rect.width * 0.5f + to.rect.xMin, to.rect.height * 0.5f + to.rect.yMin);
+                return to.anchoredPosition + localPoint - pivotDerivedOffset;
+            }
+        }
+	}
+}
+#endif

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModuleUI.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 046547dc007b98f459ad038a79356c4e
+timeCreated: 1571306506
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs

@@ -0,0 +1,301 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+using System;
+using UnityEngine;
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Options;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+    /// <summary>
+    /// Shortcuts/functions that are not strictly related to specific Modules
+    /// but are available only on some Unity versions
+    /// </summary>
+	public static class DOTweenModuleUnityVersion
+    {
+#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1_OR_NEWER
+        #region Unity 4.3 or Newer
+
+        #region Material
+
+        /// <summary>Tweens a Material's color using the given gradient
+        /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
+        public static Sequence DOGradientColor(this Material target, Gradient gradient, float duration)
+        {
+            Sequence s = DOTween.Sequence();
+            GradientColorKey[] colors = gradient.colorKeys;
+            int len = colors.Length;
+            for (int i = 0; i < len; ++i) {
+                GradientColorKey c = colors[i];
+                if (i == 0 && c.time <= 0) {
+                    target.color = c.color;
+                    continue;
+                }
+                float colorDuration = i == len - 1
+                    ? duration - s.Duration(false) // Verifies that total duration is correct
+                    : duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
+                s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
+            }
+            s.SetTarget(target);
+            return s;
+        }
+        /// <summary>Tweens a Material's named color property using the given gradient
+        /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="gradient">The gradient to use</param>
+        /// <param name="property">The name of the material property to tween (like _Tint or _SpecColor)</param>
+        /// <param name="duration">The duration of the tween</param>
+        public static Sequence DOGradientColor(this Material target, Gradient gradient, string property, float duration)
+        {
+            Sequence s = DOTween.Sequence();
+            GradientColorKey[] colors = gradient.colorKeys;
+            int len = colors.Length;
+            for (int i = 0; i < len; ++i) {
+                GradientColorKey c = colors[i];
+                if (i == 0 && c.time <= 0) {
+                    target.SetColor(property, c.color);
+                    continue;
+                }
+                float colorDuration = i == len - 1
+                    ? duration - s.Duration(false) // Verifies that total duration is correct
+                    : duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
+                s.Append(target.DOColor(c.color, property, colorDuration).SetEase(Ease.Linear));
+            }
+            s.SetTarget(target);
+            return s;
+        }
+
+        #endregion
+
+        #endregion
+#endif
+
+#if UNITY_5_3_OR_NEWER || UNITY_2017_1_OR_NEWER
+        #region Unity 5.3 or Newer
+
+        #region CustomYieldInstructions
+
+        /// <summary>
+        /// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or complete.
+        /// It can be used inside a coroutine as a yield.
+        /// <para>Example usage:</para><code>yield return myTween.WaitForCompletion(true);</code>
+        /// </summary>
+        public static CustomYieldInstruction WaitForCompletion(this Tween t, bool returnCustomYieldInstruction)
+        {
+            if (!t.active) {
+                if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
+                return null;
+            }
+            return new DOTweenCYInstruction.WaitForCompletion(t);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or rewinded.
+        /// It can be used inside a coroutine as a yield.
+        /// <para>Example usage:</para><code>yield return myTween.WaitForRewind();</code>
+        /// </summary>
+        public static CustomYieldInstruction WaitForRewind(this Tween t, bool returnCustomYieldInstruction)
+        {
+            if (!t.active) {
+                if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
+                return null;
+            }
+            return new DOTweenCYInstruction.WaitForRewind(t);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed.
+        /// It can be used inside a coroutine as a yield.
+        /// <para>Example usage:</para><code>yield return myTween.WaitForKill();</code>
+        /// </summary>
+        public static CustomYieldInstruction WaitForKill(this Tween t, bool returnCustomYieldInstruction)
+        {
+            if (!t.active) {
+                if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
+                return null;
+            }
+            return new DOTweenCYInstruction.WaitForKill(t);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or has gone through the given amount of loops.
+        /// It can be used inside a coroutine as a yield.
+        /// <para>Example usage:</para><code>yield return myTween.WaitForElapsedLoops(2);</code>
+        /// </summary>
+        /// <param name="elapsedLoops">Elapsed loops to wait for</param>
+        public static CustomYieldInstruction WaitForElapsedLoops(this Tween t, int elapsedLoops, bool returnCustomYieldInstruction)
+        {
+            if (!t.active) {
+                if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
+                return null;
+            }
+            return new DOTweenCYInstruction.WaitForElapsedLoops(t, elapsedLoops);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or has reached the given position (loops included, delays excluded).
+        /// It can be used inside a coroutine as a yield.
+        /// <para>Example usage:</para><code>yield return myTween.WaitForPosition(2.5f);</code>
+        /// </summary>
+        /// <param name="position">Position (loops included, delays excluded) to wait for</param>
+        public static CustomYieldInstruction WaitForPosition(this Tween t, float position, bool returnCustomYieldInstruction)
+        {
+            if (!t.active) {
+                if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
+                return null;
+            }
+            return new DOTweenCYInstruction.WaitForPosition(t, position);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or started
+        /// (meaning when the tween is set in a playing state the first time, after any eventual delay).
+        /// It can be used inside a coroutine as a yield.
+        /// <para>Example usage:</para><code>yield return myTween.WaitForStart();</code>
+        /// </summary>
+        public static CustomYieldInstruction WaitForStart(this Tween t, bool returnCustomYieldInstruction)
+        {
+            if (!t.active) {
+                if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
+                return null;
+            }
+            return new DOTweenCYInstruction.WaitForStart(t);
+        }
+
+        #endregion
+
+        #endregion
+#endif
+
+#if UNITY_2018_1_OR_NEWER
+        #region Unity 2018.1 or Newer
+
+        #region Material
+
+        /// <summary>Tweens a Material's named texture offset property with the given ID to the given value.
+        /// Also stores the material as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="propertyID">The ID of the material property to tween (also called nameID in Unity's manual)</param>
+        /// <param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOOffset(this Material target, Vector2 endValue, int propertyID, float duration)
+        {
+            if (!target.HasProperty(propertyID)) {
+                if (Debugger.logPriority > 0) Debugger.LogMissingMaterialProperty(propertyID);
+                return null;
+            }
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.GetTextureOffset(propertyID), x => target.SetTextureOffset(propertyID, x), endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Material's named texture scale property with the given ID to the given value.
+        /// Also stores the material as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="propertyID">The ID of the material property to tween (also called nameID in Unity's manual)</param>
+        /// <param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOTiling(this Material target, Vector2 endValue, int propertyID, float duration)
+        {
+            if (!target.HasProperty(propertyID)) {
+                if (Debugger.logPriority > 0) Debugger.LogMissingMaterialProperty(propertyID);
+                return null;
+            }
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.GetTextureScale(propertyID), x => target.SetTextureScale(propertyID, x), endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #endregion
+#endif
+    }
+
+    // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+    // ███ CLASSES █████████████████████████████████████████████████████████████████████████████████████████████████████████
+    // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+
+#if UNITY_5_3_OR_NEWER || UNITY_2017_1_OR_NEWER
+    public static class DOTweenCYInstruction
+    {
+        public class WaitForCompletion : CustomYieldInstruction
+        {
+            public override bool keepWaiting { get {
+                return t.active && !t.IsComplete();
+            }}
+            readonly Tween t;
+            public WaitForCompletion(Tween tween)
+            {
+                t = tween;
+            }
+        }
+
+        public class WaitForRewind : CustomYieldInstruction
+        {
+            public override bool keepWaiting { get {
+                return t.active && (!t.playedOnce || t.position * (t.CompletedLoops() + 1) > 0);
+            }}
+            readonly Tween t;
+            public WaitForRewind(Tween tween)
+            {
+                t = tween;
+            }
+        }
+
+        public class WaitForKill : CustomYieldInstruction
+        {
+            public override bool keepWaiting { get {
+                return t.active;
+            }}
+            readonly Tween t;
+            public WaitForKill(Tween tween)
+            {
+                t = tween;
+            }
+        }
+
+        public class WaitForElapsedLoops : CustomYieldInstruction
+        {
+            public override bool keepWaiting { get {
+                return t.active && t.CompletedLoops() < elapsedLoops;
+            }}
+            readonly Tween t;
+            readonly int elapsedLoops;
+            public WaitForElapsedLoops(Tween tween, int elapsedLoops)
+            {
+                t = tween;
+                this.elapsedLoops = elapsedLoops;
+            }
+        }
+
+        public class WaitForPosition : CustomYieldInstruction
+        {
+            public override bool keepWaiting { get {
+                return t.active && t.position * (t.CompletedLoops() + 1) < position;
+            }}
+            readonly Tween t;
+            readonly float position;
+            public WaitForPosition(Tween tween, float position)
+            {
+                t = tween;
+                this.position = position;
+            }
+        }
+
+        public class WaitForStart : CustomYieldInstruction
+        {
+            public override bool keepWaiting { get {
+                return t.active && !t.playedOnce;
+            }}
+            readonly Tween t;
+            public WaitForStart(Tween tween)
+            {
+                t = tween;
+            }
+        }
+    }
+#endif
+}

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5b0fda71852649440aada8717daae3ed
+timeCreated: 1571306506
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs

@@ -0,0 +1,155 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+using System;
+using System.Reflection;
+using UnityEngine;
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Core.PathCore;
+using DG.Tweening.Plugins.Options;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+    /// <summary>
+    /// Utility functions that deal with available Modules.
+    /// Modules defines:
+    /// - DOTAUDIO
+    /// - DOTPHYSICS
+    /// - DOTPHYSICS2D
+    /// - DOTSPRITE
+    /// - DOTUI
+    /// Extra defines set and used for implementation of external assets:
+    /// - DOTWEEN_TMP ► TextMesh Pro
+    /// - DOTWEEN_TK2D ► 2D Toolkit
+    /// </summary>
+	public static class DOTweenModuleUtils
+    {
+        static bool _initialized;
+
+        #region Reflection
+
+        /// <summary>
+        /// Called via Reflection by DOTweenComponent on Awake
+        /// </summary>
+#if UNITY_2018_1_OR_NEWER
+        [UnityEngine.Scripting.Preserve]
+#endif
+        public static void Init()
+        {
+            if (_initialized) return;
+
+            _initialized = true;
+            DOTweenExternalCommand.SetOrientationOnPath += Physics.SetOrientationOnPath;
+
+#if UNITY_EDITOR
+#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1
+            UnityEditor.EditorApplication.playmodeStateChanged += PlaymodeStateChanged;
+#else
+            UnityEditor.EditorApplication.playModeStateChanged += PlaymodeStateChanged;
+#endif
+#endif
+        }
+
+#if UNITY_2018_1_OR_NEWER
+#pragma warning disable
+        [UnityEngine.Scripting.Preserve]
+        // Just used to preserve methods when building, never called
+        static void Preserver()
+        {
+            Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
+            MethodInfo mi = typeof(MonoBehaviour).GetMethod("Stub");
+        }
+#pragma warning restore
+#endif
+
+        #endregion
+
+#if UNITY_EDITOR
+        // Fires OnApplicationPause in DOTweenComponent even when Editor is paused (otherwise it's only fired at runtime)
+#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1
+        static void PlaymodeStateChanged()
+        #else
+        static void PlaymodeStateChanged(UnityEditor.PlayModeStateChange state)
+#endif
+        {
+            if (DOTween.instance == null) return;
+            DOTween.instance.OnApplicationPause(UnityEditor.EditorApplication.isPaused);
+        }
+#endif
+
+        // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+        // ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████
+        // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+
+        public static class Physics
+        {
+            // Called via DOTweenExternalCommand callback
+            public static void SetOrientationOnPath(PathOptions options, Tween t, Quaternion newRot, Transform trans)
+            {
+#if true // PHYSICS_MARKER
+                if (options.isRigidbody) ((Rigidbody)t.target).rotation = newRot;
+                else trans.rotation = newRot;
+#else
+                trans.rotation = newRot;
+#endif
+            }
+
+            // Returns FALSE if the DOTween's Physics2D Module is disabled, or if there's no Rigidbody2D attached
+            public static bool HasRigidbody2D(Component target)
+            {
+#if true // PHYSICS2D_MARKER
+                return target.GetComponent<Rigidbody2D>() != null;
+#else
+                return false;
+#endif
+            }
+
+            #region Called via Reflection
+
+
+            // Called via Reflection by DOTweenPathInspector
+            // Returns FALSE if the DOTween's Physics Module is disabled, or if there's no rigidbody attached
+#if UNITY_2018_1_OR_NEWER
+            [UnityEngine.Scripting.Preserve]
+#endif
+            public static bool HasRigidbody(Component target)
+            {
+#if true // PHYSICS_MARKER
+                return target.GetComponent<Rigidbody>() != null;
+#else
+                return false;
+#endif
+            }
+
+            // Called via Reflection by DOTweenPath
+#if UNITY_2018_1_OR_NEWER
+            [UnityEngine.Scripting.Preserve]
+#endif
+            public static TweenerCore<Vector3, Path, PathOptions> CreateDOTweenPathTween(
+                MonoBehaviour target, bool tweenRigidbody, bool isLocal, Path path, float duration, PathMode pathMode
+            ){
+                TweenerCore<Vector3, Path, PathOptions> t;
+#if true // PHYSICS_MARKER
+                Rigidbody rBody = tweenRigidbody ? target.GetComponent<Rigidbody>() : null;
+                if (tweenRigidbody && rBody != null) {
+                    t = isLocal
+                        ? rBody.DOLocalPath(path, duration, pathMode)
+                        : rBody.DOPath(path, duration, pathMode);
+                } else {
+                    t = isLocal
+                        ? target.transform.DOLocalPath(path, duration, pathMode)
+                        : target.transform.DOPath(path, duration, pathMode);
+                }
+#else
+                t = isLocal
+                    ? target.transform.DOLocalPath(path, duration, pathMode)
+                    : target.transform.DOPath(path, duration, pathMode);
+#endif
+                return t;
+            }
+
+            #endregion
+        }
+    }
+}

UnityExamples.Unity5/Assets/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 13102a7bb129af445aa4943ee333feb9
+timeCreated: 1571306506
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityExamples.Unity5/Assets/Demigiant/DOTween/readme.txt

@@ -1,8 +1,18 @@
-DOTween and DOTween Pro are copyright (c) 2014 Daniele Giardini - Demigiant
+DOTween and DOTween Pro are copyright (c) 2014-2018 Daniele Giardini - Demigiant
+
+// IMPORTANT!!! /////////////////////////////////////////////
+// Upgrading DOTween from versions older than 1.2.000 ///////
+// (or DOTween Pro older than 1.0.000) //////////////////////
+-------------------------------------------------------------
+If you're upgrading your project from a version of DOTween older than 1.2.000 (or DOTween Pro older than 1.0.000) please follow these instructions carefully.
+1) Import the new version in the same folder as the previous one, overwriting old files. A lot of errors will appear but don't worry
+2) Close and reopen Unity (and your project). This is fundamental: skipping this step will cause a bloodbath
+3) Open DOTween's Utility Panel (Tools > Demigiant > DOTween Utility Panel) if it doesn't open automatically, then press "Setup DOTween...": this will run the upgrade setup
+4) From the Add/Remove Modules panel that opens, activate/deactivate Modules for Unity systems and for external assets (Pro version only)
 
 // GET STARTED //////////////////////////////////////////////
 
-- After importing a new DOTween update, select DOTween's Utility Panel from the Tools menu (if it doesn't open automatically) and press the "Setup DOTween..." button to set up additional features based on your Unity version.
+- After importing a new DOTween update, select DOTween's Utility Panel from the "Tools/Demigiant" menu (if it doesn't open automatically) and press the "Setup DOTween..." button to activate/deactivate Modules. You can also access a Preferences Tab from there to choose default settings for DOTween.
 - In your code, add "using DG.Tweening" to each class where you want to use DOTween.
 - You're ready to tween. Check out the links below for full documentation and license info.
 
@@ -12,7 +22,8 @@ DOTween and DOTween Pro are copyright (c) 2014 Daniele Giardini - Demigiant
 DOTween website (documentation, examples, etc): http://dotween.demigiant.com
 DOTween license: http://dotween.demigiant.com/license.php
 DOTween repository (Google Code): https://code.google.com/p/dotween/
+Demigiant website (documentation, examples, etc): http://www.demigiant.com
 
 // NOTES //////////////////////////////////////////////////////
 
-- DOTween's Utility Panel can be found under "Tools > DOTween Utility Panel" and also contains other useful options, plus a tab to set DOTween's preferences
+- DOTween's Utility Panel can be found under "Tools > Demigiant > DOTween Utility Panel" and also contains other useful options, plus a tab to set DOTween's preferences

UnityExamples.Unity5/ProjectSettings/ProjectVersion.txt

@@ -1,2 +1 @@
-m_EditorVersion: 5.3.5f1
+m_EditorVersion: 5.6.5f1
-m_StandardAssetsVersion: 0

UnityTests.Unity5/Assets/Demigiant/DemiLib/Core/Editor/Imgs/whiteSquare.png.meta

@@ -1,6 +1,6 @@
 fileFormatVersion: 2
 guid: d3e15b806a8368742ba6f10e794d7b76
-timeCreated: 1569668746
+timeCreated: 1571307125
 licenseType: Pro
 TextureImporter:
   fileIDToRecycleName: {}