UnityMirror/dotween-upm-fork
1
0
Fork 0
mirror of https://github.com/Cardidi/dotween-upm-fork.git synced 2025-12-20 09:16:02 +08:00
Code

Implemented new hyper-compatibility mode (works on WP8.1) using faster wrappers instead of surrogates for Unity structs

Browse Source
This commit is contained in:
Daniele Giardini 2015-04-20 19:57:39 +02:00
parent a5b9515df9
commit 847813ac40
84 changed files with 1003 additions and 1426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
UnityCompatibilityTests.Unity35/Assets/Demigiant/DOTween/DOTween.XML
View File

@ -532,39 +532,39 @@
<summary>Options for float tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector2,UnityEngine.Vector2,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<summary>Options for Vector2 tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector2,UnityEngine.Vector2,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<summary>Options for Vector2 tweens</summary>
<param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector3,UnityEngine.Vector3,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<summary>Options for Vector3 tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector3,UnityEngine.Vector3,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<summary>Options for Vector3 tweens</summary>
<param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector4,UnityEngine.Vector4,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<summary>Options for Vector4 tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector4,UnityEngine.Vector4,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<summary>Options for Vector4 tweens</summary>
<param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Quaternion,UnityEngine.Vector3,DG.Tweening.Plugins.Options.QuaternionOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.QuaternionWrapper,DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Plugins.Options.QuaternionOptions},System.Boolean)">
<summary>Options for Quaternion tweens</summary>
<param name="useShortest360Route">If TRUE (default) the rotation will take the shortest route, and will not rotate more than 360°.
If FALSE the rotation will be fully accounted. Is always FALSE if the tween is set as relative</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Color,UnityEngine.Color,DG.Tweening.Plugins.Options.ColorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.ColorWrapper,DG.Tweening.Core.Surrogates.ColorWrapper,DG.Tweening.Plugins.Options.ColorOptions},System.Boolean)">
<summary>Options for Color tweens</summary>
<param name="alphaOnly">If TRUE only the alpha value of the color will be tweened</param>
</member>
@ -1507,7 +1507,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Vector2},DG.Tweening.Core.DOSetter{UnityEngine.Vector2},UnityEngine.Vector2,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector2Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector2Wrapper},UnityEngine.Vector2,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1515,7 +1515,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Vector3},DG.Tweening.Core.DOSetter{UnityEngine.Vector3},UnityEngine.Vector3,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},UnityEngine.Vector3,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1523,7 +1523,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Vector4},DG.Tweening.Core.DOSetter{UnityEngine.Vector4},UnityEngine.Vector4,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector4Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector4Wrapper},UnityEngine.Vector4,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1531,7 +1531,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Quaternion},DG.Tweening.Core.DOSetter{UnityEngine.Quaternion},UnityEngine.Vector3,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.QuaternionWrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.QuaternionWrapper},UnityEngine.Vector3,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1539,7 +1539,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Color},DG.Tweening.Core.DOSetter{UnityEngine.Color},UnityEngine.Color,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.ColorWrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.ColorWrapper},UnityEngine.Color,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1574,7 +1574,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.ToAxis(DG.Tweening.Core.DOGetter{UnityEngine.Vector3},DG.Tweening.Core.DOSetter{UnityEngine.Vector3},System.Single,System.Single,DG.Tweening.AxisConstraint)">
<member name="M:DG.Tweening.DOTween.ToAxis(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},System.Single,System.Single,DG.Tweening.AxisConstraint)">
<summary>Tweens only one axis of a Vector3 to the given value using default plugins.</summary>
<param name="getter">A getter for the field or property to tween.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1583,7 +1583,7 @@
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
<param name="axisConstraint">The axis to tween</param>
</member>
<member name="M:DG.Tweening.DOTween.ToAlpha(DG.Tweening.Core.DOGetter{UnityEngine.Color},DG.Tweening.Core.DOSetter{UnityEngine.Color},System.Single,System.Single)">
<member name="M:DG.Tweening.DOTween.ToAlpha(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.ColorWrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.ColorWrapper},System.Single,System.Single)">
<summary>Tweens only the alpha of a Color to the given value using default plugins</summary>
<param name="getter">A getter for the field or property to tween.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>

BIN
UnityCompatibilityTests.Unity35/Assets/Demigiant/DOTween/DOTween.dll
View File

Binary file not shown.

BIN
UnityCompatibilityTests.Unity35/Assets/Demigiant/DOTween/DOTween.dll.mdb
View File

Binary file not shown.

BIN
UnityCompatibilityTests.Unity35/Assets/Demigiant/DOTween/DOTween43.dll
View File

Binary file not shown.

BIN
UnityCompatibilityTests.Unity35/Assets/Demigiant/DOTween/DOTween43.dll.mdb
View File

Binary file not shown.

BIN
UnityCompatibilityTests.Unity35/Assets/Demigiant/DOTween/DOTween46.dll
View File

Binary file not shown.

BIN
UnityCompatibilityTests.Unity35/Assets/Demigiant/DOTween/DOTween46.dll.mdb
View File

Binary file not shown.

BIN
UnityCompatibilityTests.Unity35/Assets/Demigiant/DOTween/DOTween50.dll
View File

Binary file not shown.

BIN
UnityCompatibilityTests.Unity35/Assets/Demigiant/DOTween/DOTween50.dll.mdb
View File

Binary file not shown.

BIN
UnityCompatibilityTests.Unity35/Assets/Demigiant/DOTween/Editor/DOTweenEditor.dll
View File

Binary file not shown.

BIN
UnityCompatibilityTests.Unity35/Assets/Demigiant/DOTween/Editor/DOTweenEditor.dll.mdb
View File

Binary file not shown.

30
UnityTests.Unity4/Assets/Demigiant/DOTween/DOTween.XML
View File

@ -532,39 +532,39 @@
<summary>Options for float tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector2,UnityEngine.Vector2,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<summary>Options for Vector2 tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector2,UnityEngine.Vector2,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<summary>Options for Vector2 tweens</summary>
<param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector3,UnityEngine.Vector3,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<summary>Options for Vector3 tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector3,UnityEngine.Vector3,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<summary>Options for Vector3 tweens</summary>
<param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector4,UnityEngine.Vector4,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<summary>Options for Vector4 tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector4,UnityEngine.Vector4,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<summary>Options for Vector4 tweens</summary>
<param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Quaternion,UnityEngine.Vector3,DG.Tweening.Plugins.Options.QuaternionOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.QuaternionWrapper,DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Plugins.Options.QuaternionOptions},System.Boolean)">
<summary>Options for Quaternion tweens</summary>
<param name="useShortest360Route">If TRUE (default) the rotation will take the shortest route, and will not rotate more than 360°.
If FALSE the rotation will be fully accounted. Is always FALSE if the tween is set as relative</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Color,UnityEngine.Color,DG.Tweening.Plugins.Options.ColorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.ColorWrapper,DG.Tweening.Core.Surrogates.ColorWrapper,DG.Tweening.Plugins.Options.ColorOptions},System.Boolean)">
<summary>Options for Color tweens</summary>
<param name="alphaOnly">If TRUE only the alpha value of the color will be tweened</param>
</member>
@ -1507,7 +1507,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Vector2},DG.Tweening.Core.DOSetter{UnityEngine.Vector2},UnityEngine.Vector2,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector2Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector2Wrapper},UnityEngine.Vector2,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1515,7 +1515,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Vector3},DG.Tweening.Core.DOSetter{UnityEngine.Vector3},UnityEngine.Vector3,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},UnityEngine.Vector3,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1523,7 +1523,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Vector4},DG.Tweening.Core.DOSetter{UnityEngine.Vector4},UnityEngine.Vector4,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector4Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector4Wrapper},UnityEngine.Vector4,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1531,7 +1531,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Quaternion},DG.Tweening.Core.DOSetter{UnityEngine.Quaternion},UnityEngine.Vector3,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.QuaternionWrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.QuaternionWrapper},UnityEngine.Vector3,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1539,7 +1539,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Color},DG.Tweening.Core.DOSetter{UnityEngine.Color},UnityEngine.Color,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.ColorWrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.ColorWrapper},UnityEngine.Color,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1574,7 +1574,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.ToAxis(DG.Tweening.Core.DOGetter{UnityEngine.Vector3},DG.Tweening.Core.DOSetter{UnityEngine.Vector3},System.Single,System.Single,DG.Tweening.AxisConstraint)">
<member name="M:DG.Tweening.DOTween.ToAxis(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},System.Single,System.Single,DG.Tweening.AxisConstraint)">
<summary>Tweens only one axis of a Vector3 to the given value using default plugins.</summary>
<param name="getter">A getter for the field or property to tween.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1583,7 +1583,7 @@
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
<param name="axisConstraint">The axis to tween</param>
</member>
<member name="M:DG.Tweening.DOTween.ToAlpha(DG.Tweening.Core.DOGetter{UnityEngine.Color},DG.Tweening.Core.DOSetter{UnityEngine.Color},System.Single,System.Single)">
<member name="M:DG.Tweening.DOTween.ToAlpha(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.ColorWrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.ColorWrapper},System.Single,System.Single)">
<summary>Tweens only the alpha of a Color to the given value using default plugins</summary>
<param name="getter">A getter for the field or property to tween.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>

BIN
UnityTests.Unity4/Assets/Demigiant/DOTween/DOTween.dll
View File

Binary file not shown.

BIN
UnityTests.Unity4/Assets/Demigiant/DOTween/DOTween.dll.mdb
View File

Binary file not shown.

BIN
UnityTests.Unity4/Assets/Demigiant/DOTween/DOTween43.dll
View File

Binary file not shown.

BIN
UnityTests.Unity4/Assets/Demigiant/DOTween/DOTween43.dll.mdb
View File

Binary file not shown.

BIN
UnityTests.Unity4/Assets/Demigiant/DOTween/DOTween46.dll
View File

Binary file not shown.

BIN
UnityTests.Unity4/Assets/Demigiant/DOTween/DOTween46.dll.mdb
View File

Binary file not shown.

BIN
UnityTests.Unity4/Assets/Demigiant/DOTween/DOTween50.dll
View File

Binary file not shown.

BIN
UnityTests.Unity4/Assets/Demigiant/DOTween/DOTween50.dll.mdb
View File

Binary file not shown.

BIN
UnityTests.Unity4/Assets/Demigiant/DOTween/Editor/DOTweenEditor.dll
View File

Binary file not shown.

BIN
UnityTests.Unity4/Assets/Demigiant/DOTween/Editor/DOTweenEditor.dll.mdb
View File

Binary file not shown.

30
UnityTests.Unity5/Assets/Demigiant/DOTween/DOTween.XML
View File

@ -532,39 +532,39 @@
<summary>Options for float tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector2,UnityEngine.Vector2,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<summary>Options for Vector2 tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector2,UnityEngine.Vector2,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<summary>Options for Vector2 tweens</summary>
<param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector3,UnityEngine.Vector3,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<summary>Options for Vector3 tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector3,UnityEngine.Vector3,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<summary>Options for Vector3 tweens</summary>
<param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector4,UnityEngine.Vector4,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<summary>Options for Vector4 tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector4,UnityEngine.Vector4,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<summary>Options for Vector4 tweens</summary>
<param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Quaternion,UnityEngine.Vector3,DG.Tweening.Plugins.Options.QuaternionOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.QuaternionWrapper,DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Plugins.Options.QuaternionOptions},System.Boolean)">
<summary>Options for Quaternion tweens</summary>
<param name="useShortest360Route">If TRUE (default) the rotation will take the shortest route, and will not rotate more than 360°.
If FALSE the rotation will be fully accounted. Is always FALSE if the tween is set as relative</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Color,UnityEngine.Color,DG.Tweening.Plugins.Options.ColorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.ColorWrapper,DG.Tweening.Core.Surrogates.ColorWrapper,DG.Tweening.Plugins.Options.ColorOptions},System.Boolean)">
<summary>Options for Color tweens</summary>
<param name="alphaOnly">If TRUE only the alpha value of the color will be tweened</param>
</member>
@ -1507,7 +1507,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Vector2},DG.Tweening.Core.DOSetter{UnityEngine.Vector2},UnityEngine.Vector2,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector2Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector2Wrapper},UnityEngine.Vector2,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1515,7 +1515,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Vector3},DG.Tweening.Core.DOSetter{UnityEngine.Vector3},UnityEngine.Vector3,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},UnityEngine.Vector3,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1523,7 +1523,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Vector4},DG.Tweening.Core.DOSetter{UnityEngine.Vector4},UnityEngine.Vector4,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector4Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector4Wrapper},UnityEngine.Vector4,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1531,7 +1531,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Quaternion},DG.Tweening.Core.DOSetter{UnityEngine.Quaternion},UnityEngine.Vector3,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.QuaternionWrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.QuaternionWrapper},UnityEngine.Vector3,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1539,7 +1539,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Color},DG.Tweening.Core.DOSetter{UnityEngine.Color},UnityEngine.Color,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.ColorWrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.ColorWrapper},UnityEngine.Color,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1574,7 +1574,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.ToAxis(DG.Tweening.Core.DOGetter{UnityEngine.Vector3},DG.Tweening.Core.DOSetter{UnityEngine.Vector3},System.Single,System.Single,DG.Tweening.AxisConstraint)">
<member name="M:DG.Tweening.DOTween.ToAxis(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},System.Single,System.Single,DG.Tweening.AxisConstraint)">
<summary>Tweens only one axis of a Vector3 to the given value using default plugins.</summary>
<param name="getter">A getter for the field or property to tween.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1583,7 +1583,7 @@
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
<param name="axisConstraint">The axis to tween</param>
</member>
<member name="M:DG.Tweening.DOTween.ToAlpha(DG.Tweening.Core.DOGetter{UnityEngine.Color},DG.Tweening.Core.DOSetter{UnityEngine.Color},System.Single,System.Single)">
<member name="M:DG.Tweening.DOTween.ToAlpha(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.ColorWrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.ColorWrapper},System.Single,System.Single)">
<summary>Tweens only the alpha of a Color to the given value using default plugins</summary>
<param name="getter">A getter for the field or property to tween.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>

BIN
UnityTests.Unity5/Assets/Demigiant/DOTween/DOTween.dll
View File

Binary file not shown.

BIN
UnityTests.Unity5/Assets/Demigiant/DOTween/DOTween.dll.mdb
View File

Binary file not shown.

BIN
UnityTests.Unity5/Assets/Demigiant/DOTween/DOTween43.dll
View File

Binary file not shown.

BIN
UnityTests.Unity5/Assets/Demigiant/DOTween/DOTween43.dll.mdb
View File

Binary file not shown.

BIN
UnityTests.Unity5/Assets/Demigiant/DOTween/DOTween46.dll
View File

Binary file not shown.

BIN
UnityTests.Unity5/Assets/Demigiant/DOTween/DOTween46.dll.mdb
View File

Binary file not shown.

BIN
UnityTests.Unity5/Assets/Demigiant/DOTween/DOTween50.dll
View File

Binary file not shown.

BIN
UnityTests.Unity5/Assets/Demigiant/DOTween/DOTween50.dll.mdb
View File

Binary file not shown.

BIN
UnityTests.Unity5/Assets/Demigiant/DOTween/Editor/DOTweenEditor.dll
View File

Binary file not shown.

BIN
UnityTests.Unity5/Assets/Demigiant/DOTween/Editor/DOTweenEditor.dll.mdb
View File

Binary file not shown.

30
_DOTween.Assembly/DOTween.sln
View File

@ -17,53 +17,53 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DOTween50", "DOTween50\DOTw
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
CompatibilityMode|Any CPU = CompatibilityMode|Any CPU
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
WP81|Any CPU = WP81|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{DE17C145-3E8D-45D6-BBB6-D06BD7D80A55}.CompatibilityMode|Any CPU.ActiveCfg = CompatibilityMode|Any CPU
{DE17C145-3E8D-45D6-BBB6-D06BD7D80A55}.CompatibilityMode|Any CPU.Build.0 = CompatibilityMode|Any CPU
{DE17C145-3E8D-45D6-BBB6-D06BD7D80A55}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{DE17C145-3E8D-45D6-BBB6-D06BD7D80A55}.Debug|Any CPU.Build.0 = Debug|Any CPU
{DE17C145-3E8D-45D6-BBB6-D06BD7D80A55}.Release|Any CPU.ActiveCfg = Release|Any CPU
{DE17C145-3E8D-45D6-BBB6-D06BD7D80A55}.Release|Any CPU.Build.0 = Release|Any CPU
{DE17C145-3E8D-45D6-BBB6-D06BD7D80A55}.WP81|Any CPU.ActiveCfg = WP81|Any CPU
{DE17C145-3E8D-45D6-BBB6-D06BD7D80A55}.WP81|Any CPU.Build.0 = WP81|Any CPU
{421ACC19-8922-4E98-8921-B52240CE172A}.CompatibilityMode|Any CPU.ActiveCfg = CompatibilityMode|Any CPU
{421ACC19-8922-4E98-8921-B52240CE172A}.CompatibilityMode|Any CPU.Build.0 = CompatibilityMode|Any CPU
{421ACC19-8922-4E98-8921-B52240CE172A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{421ACC19-8922-4E98-8921-B52240CE172A}.Debug|Any CPU.Build.0 = Debug|Any CPU
{421ACC19-8922-4E98-8921-B52240CE172A}.Release|Any CPU.ActiveCfg = Release|Any CPU
{421ACC19-8922-4E98-8921-B52240CE172A}.Release|Any CPU.Build.0 = Release|Any CPU
{421ACC19-8922-4E98-8921-B52240CE172A}.WP81|Any CPU.ActiveCfg = WP81|Any CPU
{421ACC19-8922-4E98-8921-B52240CE172A}.WP81|Any CPU.Build.0 = WP81|Any CPU
{20D2E542-D14F-4678-9C38-F3C0ECF6A2F6}.CompatibilityMode|Any CPU.ActiveCfg = CompatibilityMode|Any CPU
{20D2E542-D14F-4678-9C38-F3C0ECF6A2F6}.CompatibilityMode|Any CPU.Build.0 = CompatibilityMode|Any CPU
{20D2E542-D14F-4678-9C38-F3C0ECF6A2F6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{20D2E542-D14F-4678-9C38-F3C0ECF6A2F6}.Debug|Any CPU.Build.0 = Debug|Any CPU
{20D2E542-D14F-4678-9C38-F3C0ECF6A2F6}.Release|Any CPU.ActiveCfg = Release|Any CPU
{20D2E542-D14F-4678-9C38-F3C0ECF6A2F6}.Release|Any CPU.Build.0 = Release|Any CPU
{20D2E542-D14F-4678-9C38-F3C0ECF6A2F6}.WP81|Any CPU.ActiveCfg = WP81|Any CPU
{20D2E542-D14F-4678-9C38-F3C0ECF6A2F6}.WP81|Any CPU.Build.0 = WP81|Any CPU
{978C0952-38D0-4C22-B96C-823EAFEDF0FA}.CompatibilityMode|Any CPU.ActiveCfg = CompatibilityMode|Any CPU
{978C0952-38D0-4C22-B96C-823EAFEDF0FA}.CompatibilityMode|Any CPU.Build.0 = CompatibilityMode|Any CPU
{978C0952-38D0-4C22-B96C-823EAFEDF0FA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{978C0952-38D0-4C22-B96C-823EAFEDF0FA}.Debug|Any CPU.Build.0 = Debug|Any CPU
{978C0952-38D0-4C22-B96C-823EAFEDF0FA}.Release|Any CPU.ActiveCfg = Release|Any CPU
{978C0952-38D0-4C22-B96C-823EAFEDF0FA}.Release|Any CPU.Build.0 = Release|Any CPU
{978C0952-38D0-4C22-B96C-823EAFEDF0FA}.WP81|Any CPU.ActiveCfg = WP81|Any CPU
{978C0952-38D0-4C22-B96C-823EAFEDF0FA}.WP81|Any CPU.Build.0 = WP81|Any CPU
{279545AE-D268-42F0-A4C6-AA5BA15FB9BE}.CompatibilityMode|Any CPU.ActiveCfg = CompatibilityMode|Any CPU
{279545AE-D268-42F0-A4C6-AA5BA15FB9BE}.CompatibilityMode|Any CPU.Build.0 = CompatibilityMode|Any CPU
{279545AE-D268-42F0-A4C6-AA5BA15FB9BE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{279545AE-D268-42F0-A4C6-AA5BA15FB9BE}.Debug|Any CPU.Build.0 = Debug|Any CPU
{279545AE-D268-42F0-A4C6-AA5BA15FB9BE}.Release|Any CPU.ActiveCfg = Release|Any CPU
{279545AE-D268-42F0-A4C6-AA5BA15FB9BE}.Release|Any CPU.Build.0 = Release|Any CPU
{279545AE-D268-42F0-A4C6-AA5BA15FB9BE}.WP81|Any CPU.ActiveCfg = WP81|Any CPU
{279545AE-D268-42F0-A4C6-AA5BA15FB9BE}.WP81|Any CPU.Build.0 = WP81|Any CPU
{AC1E5A23-CE58-419C-B165-EB1CD39AB433}.CompatibilityMode|Any CPU.ActiveCfg = CompatibilityMode|Any CPU
{AC1E5A23-CE58-419C-B165-EB1CD39AB433}.CompatibilityMode|Any CPU.Build.0 = CompatibilityMode|Any CPU
{AC1E5A23-CE58-419C-B165-EB1CD39AB433}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{AC1E5A23-CE58-419C-B165-EB1CD39AB433}.Debug|Any CPU.Build.0 = Debug|Any CPU
{AC1E5A23-CE58-419C-B165-EB1CD39AB433}.Release|Any CPU.ActiveCfg = Release|Any CPU
{AC1E5A23-CE58-419C-B165-EB1CD39AB433}.Release|Any CPU.Build.0 = Release|Any CPU
{AC1E5A23-CE58-419C-B165-EB1CD39AB433}.WP81|Any CPU.ActiveCfg = WP81|Any CPU
{AC1E5A23-CE58-419C-B165-EB1CD39AB433}.WP81|Any CPU.Build.0 = WP81|Any CPU
{930C3B07-B00A-44B8-A8E5-452A8FD125C7}.CompatibilityMode|Any CPU.ActiveCfg = CompatibilityMode|Any CPU
{930C3B07-B00A-44B8-A8E5-452A8FD125C7}.CompatibilityMode|Any CPU.Build.0 = CompatibilityMode|Any CPU
{930C3B07-B00A-44B8-A8E5-452A8FD125C7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{930C3B07-B00A-44B8-A8E5-452A8FD125C7}.Debug|Any CPU.Build.0 = Debug|Any CPU
{930C3B07-B00A-44B8-A8E5-452A8FD125C7}.Release|Any CPU.ActiveCfg = Release|Any CPU
{930C3B07-B00A-44B8-A8E5-452A8FD125C7}.Release|Any CPU.Build.0 = Release|Any CPU
{930C3B07-B00A-44B8-A8E5-452A8FD125C7}.WP81|Any CPU.ActiveCfg = WP81|Any CPU
{930C3B07-B00A-44B8-A8E5-452A8FD125C7}.WP81|Any CPU.Build.0 = WP81|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

66
_DOTween.Assembly/DOTween/Core/Surrogates/ColorSurrogate.cs
View File

@ -1,66 +0,0 @@
using UnityEngine;
#if WP81
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/15 12:10
#pragma warning disable 1591
namespace DG.Tweening.Core.Surrogates
{
public struct ColorSurrogate
{
public float r, g, b, a;
public ColorSurrogate(float r, float g, float b, float a)
{
this.r = r;
this.g = g;
this.b = b;
this.a = a;
}
#region Operations
public static ColorSurrogate operator +(ColorSurrogate v1, ColorSurrogate v2)
{
return new ColorSurrogate(v1.r + v2.r, v1.g + v2.g, v1.b + v2.b, v1.a + v2.a);
}
public static ColorSurrogate operator -(ColorSurrogate v1, ColorSurrogate v2)
{
return new ColorSurrogate(v1.r - v2.r, v1.g - v2.g, v1.b - v2.b, v1.a - v2.a);
}
public static ColorSurrogate operator *(ColorSurrogate v1, float f)
{
return new ColorSurrogate(v1.r * f, v1.g * f, v1.b * f, v1.a * f);
}
#endregion
#region Conversions
public static implicit operator Color(ColorSurrogate v)
{
return new Color(v.r, v.g, v.b, v.a);
}
public static implicit operator ColorSurrogate(Color v)
{
return new ColorSurrogate(v.r, v.g, v.b, v.a);
}
public static implicit operator Color32(ColorSurrogate v)
{
return new Color32((byte)(Mathf.Clamp01(v.r) * 255f), (byte)(Mathf.Clamp01(v.g) * 255f), (byte)(Mathf.Clamp01(v.b) * 255f), (byte)(Mathf.Clamp01(v.a) * 255f));
}
public static implicit operator ColorSurrogate(Color32 v)
{
return new ColorSurrogate((float)v.r / 255f, (float)v.g / 255f, (float)v.b / 255f, (float)v.a / 255f);
}
#endregion
}
}
#endif

30
_DOTween.Assembly/DOTween/Core/Surrogates/ColorWrapper.cs Normal file
View File

@ -0,0 +1,30 @@
#if COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/20 17:52
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Core.Surrogates
{
public struct ColorWrapper
{
public Color value;
public ColorWrapper(Color value)
{
this.value = value;
}
public static implicit operator Color(ColorWrapper v)
{
return v.value;
}
public static implicit operator ColorWrapper(Color v)
{
return new ColorWrapper(v);
}
}
}
#endif

67
_DOTween.Assembly/DOTween/Core/Surrogates/QuaternionSurrogate.cs
View File

@ -1,67 +0,0 @@
#if WP81
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/15 18:44
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Core.Surrogates
{
public struct QuaternionSurrogate
{
public float x, y, z, w;
public QuaternionSurrogate(float x, float y, float z, float w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
#region Operations
public static QuaternionSurrogate operator *(QuaternionSurrogate lhs, QuaternionSurrogate rhs)
{
return new QuaternionSurrogate(lhs.w * rhs.x + lhs.x * rhs.w + lhs.y * rhs.z - lhs.z * rhs.y, lhs.w * rhs.y + lhs.y * rhs.w + lhs.z * rhs.x - lhs.x * rhs.z, lhs.w * rhs.z + lhs.z * rhs.w + lhs.x * rhs.y - lhs.y * rhs.x, lhs.w * rhs.w - lhs.x * rhs.x - lhs.y * rhs.y - lhs.z * rhs.z);
}
public static Vector3Surrogate operator *(QuaternionSurrogate rotation, Vector3Surrogate point)
{
float num = rotation.x * 2f;
float num2 = rotation.y * 2f;
float num3 = rotation.z * 2f;
float num4 = rotation.x * num;
float num5 = rotation.y * num2;
float num6 = rotation.z * num3;
float num7 = rotation.x * num2;
float num8 = rotation.x * num3;
float num9 = rotation.y * num3;
float num10 = rotation.w * num;
float num11 = rotation.w * num2;
float num12 = rotation.w * num3;
Vector3Surrogate result;
result.x = (1f - (num5 + num6)) * point.x + (num7 - num12) * point.y + (num8 + num11) * point.z;
result.y = (num7 + num12) * point.x + (1f - (num4 + num6)) * point.y + (num9 - num10) * point.z;
result.z = (num8 - num11) * point.x + (num9 + num10) * point.y + (1f - (num4 + num5)) * point.z;
return result;
}
#endregion
#region Conversions
public static implicit operator Quaternion(QuaternionSurrogate v)
{
return new Quaternion(v.x, v.y, v.z, v.w);
}
public static implicit operator QuaternionSurrogate(Quaternion v)
{
return new QuaternionSurrogate(v.x, v.y, v.z, v.w);
}
#endregion
}
}
#endif

30
_DOTween.Assembly/DOTween/Core/Surrogates/QuaternionWrapper.cs Normal file
View File

@ -0,0 +1,30 @@
#if COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/20 17:53
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Core.Surrogates
{
public struct QuaternionWrapper
{
public Quaternion value;
public QuaternionWrapper(Quaternion value)
{
this.value = value;
}
public static implicit operator Quaternion(QuaternionWrapper v)
{
return v.value;
}
public static implicit operator QuaternionWrapper(Quaternion v)
{
return new QuaternionWrapper(v);
}
}
}
#endif

63
_DOTween.Assembly/DOTween/Core/Surrogates/Vector2Surrogate.cs
View File

@ -1,63 +0,0 @@
#if WP81
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/14 12:42
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Core.Surrogates
{
/// <summary>
/// A surrogate for Vector2/3/4 values to work around Unity's bug when trying to cast to
/// a Vector2/3/4 plugin on WP8.1
/// </summary>
public struct Vector2Surrogate
{
public float x, y;
public float magnitude {
get { return Mathf.Sqrt(x * x + y * y); }
}
public Vector2Surrogate(float x, float y)
: this()
{
this.x = x;
this.y = y;
}
#region Operations
public static Vector2Surrogate operator +(Vector2Surrogate v1, Vector2Surrogate v2)
{
return new Vector2Surrogate(v1.x + v2.x, v1.y + v2.y);
}
public static Vector2Surrogate operator -(Vector2Surrogate v1, Vector2Surrogate v2)
{
return new Vector2Surrogate(v1.x - v2.x, v1.y - v2.y);
}
public static Vector2Surrogate operator *(Vector2Surrogate v1, float f)
{
return new Vector2Surrogate(v1.x * f, v1.y * f);
}
#endregion
#region Conversions
public static implicit operator Vector2(Vector2Surrogate v)
{
return new Vector2(v.x, v.y);
}
public static implicit operator Vector2Surrogate(Vector2 v)
{
return new Vector2Surrogate(v.x, v.y);
}
#endregion
}
}
#endif

34
_DOTween.Assembly/DOTween/Core/Surrogates/Vector2Wrapper.cs Normal file
View File

@ -0,0 +1,34 @@
#if COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/20 17:50
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Core.Surrogates
{
public struct Vector2Wrapper
{
public Vector2 value;
public Vector2Wrapper(Vector2 value)
{
this.value = value;
}
public Vector2Wrapper(float x, float y)
{
this.value = new Vector2(x, y);
}
public static implicit operator Vector2(Vector2Wrapper v)
{
return v.value;
}
public static implicit operator Vector2Wrapper(Vector2 v)
{
return new Vector2Wrapper(v);
}
}
}
#endif

72
_DOTween.Assembly/DOTween/Core/Surrogates/Vector3Surrogate.cs
View File

@ -1,72 +0,0 @@
#if WP81
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/14 12:37
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Core.Surrogates
{
/// <summary>
/// A surrogate for Vector2/3/4 values to work around Unity's bug when trying to cast to
/// a Vector2/3/4 plugin on WP8.1
/// </summary>
public struct Vector3Surrogate
{
public float x, y, z;
public static Vector3Surrogate zero {
get { return new Vector3Surrogate(0, 0, 0); }
}
public float magnitude {
get { return Mathf.Sqrt(x * x + y * y + z * z); }
}
public Vector3Surrogate(float x, float y, float z)
: this()
{
this.x = x;
this.y = y;
this.z = z;
}
#region Operations
public static Vector3Surrogate operator +(Vector3Surrogate v1, Vector3Surrogate v2)
{
return new Vector3Surrogate(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
}
public static Vector3Surrogate operator -(Vector3Surrogate v1, Vector3Surrogate v2)
{
return new Vector3Surrogate(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
}
public static Vector3Surrogate operator -(Vector3Surrogate v1)
{
return new Vector3Surrogate(-v1.x, -v1.y, -v1.z);
}
public static Vector3Surrogate operator *(Vector3Surrogate v1, float f)
{
return new Vector3Surrogate(v1.x * f, v1.y * f, v1.z * f);
}
#endregion
#region Conversions
public static implicit operator Vector3(Vector3Surrogate v)
{
return new Vector3(v.x, v.y, v.z);
}
public static implicit operator Vector3Surrogate(Vector3 v)
{
return new Vector3Surrogate(v.x, v.y, v.z);
}
#endregion
}
}
#endif

30
_DOTween.Assembly/DOTween/Core/Surrogates/Vector3Wrapper.cs Normal file
View File

@ -0,0 +1,30 @@
#if COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/20 16:57
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Core.Surrogates
{
public struct Vector3Wrapper
{
public Vector3 value;
public Vector3Wrapper(Vector3 value)
{
this.value = value;
}
public static implicit operator Vector3(Vector3Wrapper v)
{
return v.value;
}
public static implicit operator Vector3Wrapper(Vector3 v)
{
return new Vector3Wrapper(v);
}
}
}
#endif

113
_DOTween.Assembly/DOTween/Core/Surrogates/Vector4Surrogate.cs
View File

@ -1,113 +0,0 @@
#if WP81
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/14 12:10
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Core.Surrogates
{
/// <summary>
/// A surrogate for Vector2/3/4 values to work around Unity's bug when trying to cast to
/// a Vector2/3/4 plugin on WP8.1
/// </summary>
public struct Vector4Surrogate
{
public float x, y, z, w;
public float magnitude {
get { return Mathf.Sqrt(x * x + y * y + z * z + w * w); }
}
public Vector4Surrogate(float x, float y, float z, float w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
#region Operations
public static Vector4Surrogate operator +(Vector4Surrogate v1, Vector4Surrogate v2)
{
return new Vector4Surrogate(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z, v1.w + v2.w);
}
public static Vector4Surrogate operator -(Vector4Surrogate v1, Vector4Surrogate v2)
{
return new Vector4Surrogate(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z, v1.w - v2.w);
}
public static Vector4Surrogate operator *(Vector4Surrogate v1, float f)
{
return new Vector4Surrogate(v1.x * f, v1.y * f, v1.z * f, v1.w * f);
}
// public static Vector4Surrogate operator /(Vector4Surrogate v1, float f)
// {
// return new Vector4Surrogate(v1.x / f, v1.y / f, v1.z / f, v1.w / f);
// }
#endregion
#region Comparisons
// public static bool operator <(Vector4Surrogate v1, Vector4Surrogate v2)
// {
// return v1.magnitude < v2.magnitude;
// }
//
// public static bool operator <=(Vector4Surrogate v1, Vector4Surrogate v2)
// {
// return v1.magnitude <= v2.magnitude;
// }
//
// public static bool operator >(Vector4Surrogate v1, Vector4Surrogate v2)
// {
// return v1.magnitude > v2.magnitude;
// }
//
// public static bool operator >=(Vector4Surrogate v1, Vector4Surrogate v2)
// {
// return v1.magnitude >= v2.magnitude;
// }
//
// public static bool operator ==(Vector4Surrogate v1, Vector4Surrogate v2)
// {
// return v1.x == v2.x && v1.y == v2.y && v1.z == v2.z && v1.w == v2.w;
// }
//
// public static bool operator !=(Vector4Surrogate v1, Vector4Surrogate v2)
// {
// return !(v1 == v2);
// }
#endregion
#region Conversions
// public static implicit operator Vector2(Vector4Surrogate v)
// {
// return new Vector2(v.x, v.y);
// }
//
// public static implicit operator Vector3(Vector4Surrogate v)
// {
// return new Vector3(v.x, v.y, v.z);
// }
public static implicit operator Vector4(Vector4Surrogate v)
{
return new Vector4(v.x, v.y, v.z, v.w);
}
public static implicit operator Vector4Surrogate(Vector4 v)
{
return new Vector4Surrogate(v.x, v.y, v.z, v.w);
}
#endregion
}
}
#endif

30
_DOTween.Assembly/DOTween/Core/Surrogates/Vector4Wrapper.cs Normal file
View File

@ -0,0 +1,30 @@
#if COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/20 17:51
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Core.Surrogates
{
public struct Vector4Wrapper
{
public Vector4 value;
public Vector4Wrapper(Vector4 value)
{
this.value = value;
}
public static implicit operator Vector4(Vector4Wrapper v)
{
return v.value;
}
public static implicit operator Vector4Wrapper(Vector4 v)
{
return new Vector4Wrapper(v);
}
}
}
#endif

85
_DOTween.Assembly/DOTween/DOTween.cs
View File

@ -4,11 +4,19 @@
// License Copyright (c) Daniele Giardini.
// This work is subject to the terms at http://dotween.demigiant.com/license.php
#if WP81
using DG.Tweening.Core.Surrogates;
#if COMPATIBLE
using DOVector2 = DG.Tweening.Core.Surrogates.Vector2Wrapper;
using DOVector3 = DG.Tweening.Core.Surrogates.Vector3Wrapper;
using DOVector4 = DG.Tweening.Core.Surrogates.Vector4Wrapper;
using DOQuaternion = DG.Tweening.Core.Surrogates.QuaternionWrapper;
using DOColor = DG.Tweening.Core.Surrogates.ColorWrapper;
#else
using DOVector2 = UnityEngine.Vector2;
using DOVector3 = UnityEngine.Vector3;
using DOVector4 = UnityEngine.Vector4;
using DOQuaternion = UnityEngine.Quaternion;
using DOColor = UnityEngine.Color;
#endif
using System;
using System.Collections;
using System.Collections.Generic;
using DG.Tweening.Core;
using DG.Tweening.Core.Enums;
@ -24,7 +32,7 @@ namespace DG.Tweening
public class DOTween
{
/// <summary>DOTween's version</summary>
public static readonly string Version = "1.0.535";
public static readonly string Version = "1.0.600";
///////////////////////////////////////////////
// Options ////////////////////////////////////
@ -307,65 +315,40 @@ namespace DG.Tweening
/// <param name="setter">A setter for the field or property to tween
/// <para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
/// <param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
#if WP81
public static TweenerCore<Vector2Surrogate, Vector2Surrogate, VectorOptions> To(DOGetter<Vector2Surrogate> getter, DOSetter<Vector2Surrogate> setter, Vector2 endValue, float duration)
{ return ApplyTo<Vector2Surrogate, Vector2Surrogate, VectorOptions>(getter, setter, endValue, duration); }
#else
public static TweenerCore<Vector2, Vector2, VectorOptions> To(DOGetter<Vector2> getter, DOSetter<Vector2> setter, Vector2 endValue, float duration)
{ return ApplyTo<Vector2, Vector2, VectorOptions>(getter, setter, endValue, duration); }
#endif
public static TweenerCore<DOVector2, DOVector2, VectorOptions> To(DOGetter<DOVector2> getter, DOSetter<DOVector2> setter, Vector2 endValue, float duration)
{ return ApplyTo<DOVector2, DOVector2, VectorOptions>(getter, setter, endValue, duration); }
/// <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.
/// <para>Example usage with lambda:</para><code>()=> myProperty</code></param>
/// <param name="setter">A setter for the field or property to tween
/// <para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
/// <param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
#if WP81
public static TweenerCore<Vector3Surrogate, Vector3Surrogate, VectorOptions> To(DOGetter<Vector3Surrogate> getter, DOSetter<Vector3Surrogate> setter, Vector3 endValue, float duration)
{ return ApplyTo<Vector3Surrogate, Vector3Surrogate, VectorOptions>(getter, setter, endValue, duration); }
#else
public static TweenerCore<Vector3, Vector3, VectorOptions> To(DOGetter<Vector3> getter, DOSetter<Vector3> setter, Vector3 endValue, float duration)
{ return ApplyTo<Vector3, Vector3, VectorOptions>(getter, setter, endValue, duration); }
#endif
public static TweenerCore<DOVector3, DOVector3, VectorOptions> To(DOGetter<DOVector3> getter, DOSetter<DOVector3> setter, Vector3 endValue, float duration)
{ return ApplyTo<DOVector3, DOVector3, VectorOptions>(getter, setter, endValue, duration); }
/// <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.
/// <para>Example usage with lambda:</para><code>()=> myProperty</code></param>
/// <param name="setter">A setter for the field or property to tween
/// <para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
/// <param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
#if WP81
public static TweenerCore<Vector4Surrogate, Vector4Surrogate, VectorOptions> To(DOGetter<Vector4Surrogate> getter, DOSetter<Vector4Surrogate> setter, Vector4 endValue, float duration)
{ return ApplyTo<Vector4Surrogate, Vector4Surrogate, VectorOptions>(getter, setter, endValue, duration); }
#else
public static TweenerCore<Vector4, Vector4, VectorOptions> To(DOGetter<Vector4> getter, DOSetter<Vector4> setter, Vector4 endValue, float duration)
{ return ApplyTo<Vector4, Vector4, VectorOptions>(getter, setter, endValue, duration); }
#endif
public static TweenerCore<DOVector4, DOVector4, VectorOptions> To(DOGetter<DOVector4> getter, DOSetter<DOVector4> setter, Vector4 endValue, float duration)
{ return ApplyTo<DOVector4, DOVector4, VectorOptions>(getter, setter, endValue, duration); }
/// <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.
/// <para>Example usage with lambda:</para><code>()=> myProperty</code></param>
/// <param name="setter">A setter for the field or property to tween
/// <para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
/// <param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
#if WP81
public static TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> To(DOGetter<QuaternionSurrogate> getter, DOSetter<QuaternionSurrogate> setter, Vector3 endValue, float duration)
{ return ApplyTo<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions>(getter, setter, endValue, duration); }
#else
public static TweenerCore<Quaternion, Vector3, QuaternionOptions> To(DOGetter<Quaternion> getter, DOSetter<Quaternion> setter, Vector3 endValue, float duration)
{ return ApplyTo<Quaternion, Vector3, QuaternionOptions>(getter, setter, endValue, duration); }
#endif
public static TweenerCore<DOQuaternion, DOVector3, QuaternionOptions> To(DOGetter<DOQuaternion> getter, DOSetter<DOQuaternion> setter, Vector3 endValue, float duration)
{ return ApplyTo<DOQuaternion, DOVector3, QuaternionOptions>(getter, setter, endValue, duration); }
/// <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.
/// <para>Example usage with lambda:</para><code>()=> myProperty</code></param>
/// <param name="setter">A setter for the field or property to tween
/// <para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
/// <param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
#if WP81
public static TweenerCore<ColorSurrogate, ColorSurrogate, ColorOptions> To(DOGetter<ColorSurrogate> getter, DOSetter<ColorSurrogate> setter, Color endValue, float duration)
{ return ApplyTo<ColorSurrogate, ColorSurrogate, ColorOptions>(getter, setter, endValue, duration); }
#else
public static TweenerCore<Color, Color, ColorOptions> To(DOGetter<Color> getter, DOSetter<Color> setter, Color endValue, float duration)
{ return ApplyTo<Color, Color, ColorOptions>(getter, setter, endValue, duration); }
#endif
public static TweenerCore<DOColor, DOColor, ColorOptions> To(DOGetter<DOColor> getter, DOSetter<DOColor> setter, Color endValue, float duration)
{ return ApplyTo<DOColor, DOColor, ColorOptions>(getter, setter, endValue, duration); }
/// <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.
/// <para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -405,34 +388,20 @@ namespace DG.Tweening
/// <para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
/// <param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
/// <param name="axisConstraint">The axis to tween</param>
#if WP81
public static TweenerCore<Vector3Surrogate, Vector3Surrogate, VectorOptions> ToAxis(DOGetter<Vector3Surrogate> getter, DOSetter<Vector3Surrogate> setter, float endValue, float duration, AxisConstraint axisConstraint = AxisConstraint.X)
public static TweenerCore<DOVector3, DOVector3, VectorOptions> ToAxis(DOGetter<DOVector3> getter, DOSetter<DOVector3> setter, float endValue, float duration, AxisConstraint axisConstraint = AxisConstraint.X)
{
TweenerCore<Vector3Surrogate, Vector3Surrogate, VectorOptions> t = ApplyTo<Vector3Surrogate, Vector3Surrogate, VectorOptions>(getter, setter, new Vector3Surrogate(endValue, endValue, endValue), duration);
TweenerCore<DOVector3, DOVector3, VectorOptions> t = ApplyTo<DOVector3, DOVector3, VectorOptions>(getter, setter, new Vector3(endValue, endValue, endValue), duration);
t.plugOptions.axisConstraint = axisConstraint;
return t;
}
#else
public static TweenerCore<Vector3, Vector3, VectorOptions> ToAxis(DOGetter<Vector3> getter, DOSetter<Vector3> setter, float endValue, float duration, AxisConstraint axisConstraint = AxisConstraint.X)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = ApplyTo<Vector3, Vector3, VectorOptions>(getter, setter, new Vector3(endValue, endValue, endValue), duration);
t.plugOptions.axisConstraint = axisConstraint;
return t;
}
#endif
/// <summary>Tweens only the alpha of a Color to the given value using default plugins</summary>
/// <param name="getter">A getter for the field or property to tween.
/// <para>Example usage with lambda:</para><code>()=> myProperty</code></param>
/// <param name="setter">A setter for the field or property to tween
/// <para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
/// <param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
#if WP81
public static Tweener ToAlpha(DOGetter<ColorSurrogate> getter, DOSetter<ColorSurrogate> setter, float endValue, float duration)
{ return ApplyTo<ColorSurrogate, ColorSurrogate, ColorOptions>(getter, setter, new ColorSurrogate(0, 0, 0, endValue), duration).SetOptions(true); }
#else
public static Tweener ToAlpha(DOGetter<Color> getter, DOSetter<Color> setter, float endValue, float duration)
{ return ApplyTo<Color, Color, ColorOptions>(getter, setter, new Color(0, 0, 0, endValue), duration).SetOptions(true); }
#endif
public static Tweener ToAlpha(DOGetter<DOColor> getter, DOSetter<DOColor> setter, float endValue, float duration)
{ return ApplyTo<DOColor, DOColor, ColorOptions>(getter, setter, new Color(0, 0, 0, endValue), duration).SetOptions(true); }
#endregion

24
_DOTween.Assembly/DOTween/DOTween.csproj
View File

@ -34,9 +34,9 @@
<DocumentationFile>..\bin\DOTween.XML</DocumentationFile>
<NoWarn>1573</NoWarn>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'WP81|AnyCPU'">
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'CompatibilityMode|AnyCPU' ">
<OutputPath>..\bin\</OutputPath>
<DefineConstants>TRACE;WP81</DefineConstants>
<DefineConstants>TRACE;COMPATIBLE</DefineConstants>
<DocumentationFile>..\bin\DOTween.XML</DocumentationFile>
<Optimize>true</Optimize>
<NoWarn>1573</NoWarn>
@ -71,13 +71,13 @@
<Compile Include="Core\Enums\UpdateMode.cs" />
<Compile Include="Core\Extensions.cs" />
<Compile Include="Core\SequenceCallback.cs" />
<Compile Include="Core\Surrogates\ColorSurrogate.cs" />
<Compile Include="Core\Surrogates\QuaternionSurrogate.cs" />
<Compile Include="Core\Surrogates\Vector2Surrogate.cs" />
<Compile Include="Core\Surrogates\Vector3Surrogate.cs" />
<Compile Include="Core\Surrogates\ColorWrapper.cs" />
<Compile Include="Core\Surrogates\QuaternionWrapper.cs" />
<Compile Include="Core\Surrogates\Vector2Wrapper.cs" />
<Compile Include="Core\Surrogates\Vector3Wrapper.cs" />
<Compile Include="Core\Surrogates\Vector4Wrapper.cs" />
<Compile Include="Core\TweenManager.cs" />
<Compile Include="Core\Utils.cs" />
<Compile Include="Core\Surrogates\Vector4Surrogate.cs" />
<Compile Include="DOTween.cs" />
<Compile Include="DOVirtual.cs" />
<Compile Include="Ease.cs" />
@ -86,15 +86,15 @@
<Compile Include="PathMode.cs" />
<Compile Include="PathType.cs" />
<Compile Include="Plugins\Color2Plugin.cs" />
<Compile Include="Plugins\ColorSurrogatePlugin.cs" />
<Compile Include="Plugins\ColorWrapperPlugin.cs" />
<Compile Include="Plugins\Core\PathCore\ControlPoint.cs" />
<Compile Include="Plugins\LongPlugin.cs" />
<Compile Include="Plugins\Options\PathOptions.cs" />
<Compile Include="Plugins\Options\QuaternionOptions.cs" />
<Compile Include="Plugins\Options\Vector3ArrayOptions.cs" />
<Compile Include="Plugins\QuaternionSurrogatePlugin.cs" />
<Compile Include="Plugins\QuaternionWrapperPlugin.cs" />
<Compile Include="Plugins\UlongPlugin.cs" />
<Compile Include="Plugins\Vector2SurrogatePlugin.cs" />
<Compile Include="Plugins\Vector2WrapperPlugin.cs" />
<Compile Include="Plugins\Vector3ArrayPlugin.cs" />
<Compile Include="Plugins\Core\ITPlugin.cs" />
<Compile Include="Plugins\Core\SpecialPluginsUtils.cs" />
@ -103,8 +103,8 @@
<Compile Include="Plugins\Core\PathCore\LinearDecoder.cs" />
<Compile Include="Plugins\Core\PathCore\Path.cs" />
<Compile Include="Plugins\PathPlugin.cs" />
<Compile Include="Plugins\Vector3SurrogatePlugin.cs" />
<Compile Include="Plugins\Vector4SurrogatePlugin.cs" />
<Compile Include="Plugins\Vector3WrapperPlugin.cs" />
<Compile Include="Plugins\Vector4WrapperPlugin.cs" />
<Compile Include="RotateMode.cs" />
<Compile Include="ScrambleMode.cs" />
<Compile Include="TweenExtensions.cs" />

2
_DOTween.Assembly/DOTween/Plugins/ColorPlugin.cs
View File

@ -1,4 +1,4 @@
#if !WP81
#if !COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2014/07/10 14:33
//

74
_DOTween.Assembly/DOTween/Plugins/ColorSurrogatePlugin.cs
View File

@ -1,74 +0,0 @@
#if WP81
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/15 12:17
using DG.Tweening.Core;
using DG.Tweening.Core.Easing;
using DG.Tweening.Core.Surrogates;
using DG.Tweening.Plugins.Core;
using DG.Tweening.Plugins.Options;
#pragma warning disable 1591
namespace DG.Tweening.Plugins
{
public class ColorSurrogatePlugin : ABSTweenPlugin<ColorSurrogate, ColorSurrogate, ColorOptions>
{
public override void Reset(TweenerCore<ColorSurrogate, ColorSurrogate, ColorOptions> t) { }
public override void SetFrom(TweenerCore<ColorSurrogate, ColorSurrogate, ColorOptions> t, bool isRelative)
{
ColorSurrogate prevEndVal = t.endValue;
t.endValue = t.getter();
t.startValue = isRelative ? t.endValue + prevEndVal : prevEndVal;
ColorSurrogate to = t.endValue;
if (!t.plugOptions.alphaOnly) to = t.startValue;
else to.a = t.startValue.a;
t.setter(to);
}
public override ColorSurrogate ConvertToStartValue(TweenerCore<ColorSurrogate, ColorSurrogate, ColorOptions> t, ColorSurrogate value)
{
return value;
}
public override void SetRelativeEndValue(TweenerCore<ColorSurrogate, ColorSurrogate, ColorOptions> t)
{
t.endValue += t.startValue;
}
public override void SetChangeValue(TweenerCore<ColorSurrogate, ColorSurrogate, ColorOptions> t)
{
t.changeValue = t.endValue - t.startValue;
}
public override float GetSpeedBasedDuration(ColorOptions options, float unitsXSecond, ColorSurrogate changeValue)
{
return 1f / unitsXSecond;
}
public override void EvaluateAndApply(ColorOptions options, Tween t, bool isRelative, DOGetter<ColorSurrogate> getter, DOSetter<ColorSurrogate> setter, float elapsed, ColorSurrogate startValue, ColorSurrogate changeValue, float duration, bool usingInversePosition)
{
if (t.loopType == LoopType.Incremental) startValue += changeValue * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental) {
startValue += changeValue * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
float easeVal = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
if (!options.alphaOnly) {
startValue.r += changeValue.r * easeVal;
startValue.g += changeValue.g * easeVal;
startValue.b += changeValue.b * easeVal;
startValue.a += changeValue.a * easeVal;
setter(startValue);
return;
}
// Alpha only
ColorSurrogate res = getter();
res.a = startValue.a + changeValue.a * easeVal;
setter(res);
}
}
}
#endif

75
_DOTween.Assembly/DOTween/Plugins/ColorWrapperPlugin.cs Normal file
View File

@ -0,0 +1,75 @@
#if COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/20 18:17
using DG.Tweening.Core;
using DG.Tweening.Core.Easing;
using DG.Tweening.Core.Surrogates;
using DG.Tweening.Plugins.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Plugins
{
public class ColorWrapperPlugin : ABSTweenPlugin<ColorWrapper, ColorWrapper, ColorOptions>
{
public override void Reset(TweenerCore<ColorWrapper, ColorWrapper, ColorOptions> t) { }
public override void SetFrom(TweenerCore<ColorWrapper, ColorWrapper, ColorOptions> t, bool isRelative)
{
Color prevEndVal = t.endValue;
t.endValue.value = t.getter().value;
t.startValue.value = isRelative ? t.endValue.value + prevEndVal : prevEndVal;
Color to = t.endValue.value;
if (!t.plugOptions.alphaOnly) to = t.startValue.value;
else to.a = t.startValue.value.a;
t.setter(to);
}
public override ColorWrapper ConvertToStartValue(TweenerCore<ColorWrapper, ColorWrapper, ColorOptions> t, ColorWrapper value)
{
return value.value;
}
public override void SetRelativeEndValue(TweenerCore<ColorWrapper, ColorWrapper, ColorOptions> t)
{
t.endValue.value += t.startValue.value;
}
public override void SetChangeValue(TweenerCore<ColorWrapper, ColorWrapper, ColorOptions> t)
{
t.changeValue.value = t.endValue.value - t.startValue.value;
}
public override float GetSpeedBasedDuration(ColorOptions options, float unitsXSecond, ColorWrapper changeValue)
{
return 1f / unitsXSecond;
}
public override void EvaluateAndApply(ColorOptions options, Tween t, bool isRelative, DOGetter<ColorWrapper> getter, DOSetter<ColorWrapper> setter, float elapsed, ColorWrapper startValue, ColorWrapper changeValue, float duration, bool usingInversePosition)
{
if (t.loopType == LoopType.Incremental) startValue.value += changeValue.value * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental) {
startValue.value += changeValue.value * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
float easeVal = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
if (!options.alphaOnly) {
startValue.value.r += changeValue.value.r * easeVal;
startValue.value.g += changeValue.value.g * easeVal;
startValue.value.b += changeValue.value.b * easeVal;
startValue.value.a += changeValue.value.a * easeVal;
setter(startValue);
return;
}
// Alpha only
Color res = getter().value;
res.a = startValue.value.a + changeValue.value.a * easeVal;
setter(res);
}
}
}
#endif

160
_DOTween.Assembly/DOTween/Plugins/Core/PluginsManager.cs
View File

@ -4,8 +4,28 @@
// License Copyright (c) Daniele Giardini.
// This work is subject to the terms at http://dotween.demigiant.com/license.php
#if WP81
using DG.Tweening.Core.Surrogates;
#if COMPATIBLE
using DOVector2 = DG.Tweening.Core.Surrogates.Vector2Wrapper;
using DOVector3 = DG.Tweening.Core.Surrogates.Vector3Wrapper;
using DOVector4 = DG.Tweening.Core.Surrogates.Vector4Wrapper;
using DOQuaternion = DG.Tweening.Core.Surrogates.QuaternionWrapper;
using DOColor = DG.Tweening.Core.Surrogates.ColorWrapper;
using DOVector2Plugin = DG.Tweening.Plugins.Vector2WrapperPlugin;
using DOVector3Plugin = DG.Tweening.Plugins.Vector3WrapperPlugin;
using DOVector4Plugin = DG.Tweening.Plugins.Vector4WrapperPlugin;
using DOQuaternionPlugin = DG.Tweening.Plugins.QuaternionWrapperPlugin;
using DOColorPlugin = DG.Tweening.Plugins.ColorWrapperPlugin;
#else
using DOVector2 = UnityEngine.Vector2;
using DOVector3 = UnityEngine.Vector3;
using DOVector4 = UnityEngine.Vector4;
using DOQuaternion = UnityEngine.Quaternion;
using DOColor = UnityEngine.Color;
using DOVector2Plugin = DG.Tweening.Plugins.Vector2Plugin;
using DOVector3Plugin = DG.Tweening.Plugins.Vector3Plugin;
using DOVector4Plugin = DG.Tweening.Plugins.Vector4Plugin;
using DOQuaternionPlugin = DG.Tweening.Plugins.QuaternionPlugin;
using DOColorPlugin = DG.Tweening.Plugins.ColorPlugin;
#endif
using System;
using System.Collections.Generic;
@ -45,84 +65,34 @@ namespace DG.Tweening.Plugins.Core
Type t1 = typeof(T1);
Type t2 = typeof(T2);
ITweenPlugin plugin = null;
#if WP81
if (t1 == typeof(Vector3Surrogate) && t1 == t2) {
if (_vector3Plugin == null) _vector3Plugin = new Vector3SurrogatePlugin();
if (t1 == typeof(DOVector3) && t1 == t2) {
if (_vector3Plugin == null) _vector3Plugin = new DOVector3Plugin();
plugin = _vector3Plugin;
} else if (t1 == typeof(Vector3) && t2 == typeof(Vector3[])) {
if (_vector3ArrayPlugin == null) _vector3ArrayPlugin = new Vector3ArrayPlugin();
plugin = _vector3ArrayPlugin;
}
#else
if (t1 == typeof(Vector3)) {
if (t1 == t2) {
if (_vector3Plugin == null) _vector3Plugin = new Vector3Plugin();
plugin = _vector3Plugin;
} else if (t2 == typeof(Vector3[])) {
if (_vector3ArrayPlugin == null) _vector3ArrayPlugin = new Vector3ArrayPlugin();
plugin = _vector3ArrayPlugin;
}
}
#endif
#if WP81
else if (t1 == typeof(QuaternionSurrogate)) {
} else if (t1 == typeof(DOQuaternion)) {
if (t2 == typeof(Quaternion)) Debugger.LogError("Quaternion tweens require a Vector3 endValue");
else {
if (_quaternionPlugin == null) _quaternionPlugin = new QuaternionSurrogatePlugin();
if (_quaternionPlugin == null) _quaternionPlugin = new DOQuaternionPlugin();
plugin = _quaternionPlugin;
}
}
#else
else if (t1 == typeof(Quaternion)) {
if (t2 == typeof(Quaternion)) Debugger.LogError("Quaternion tweens require a Vector3 endValue");
else {
if (_quaternionPlugin == null) _quaternionPlugin = new QuaternionPlugin();
plugin = _quaternionPlugin;
}
}
#endif
#if WP81
else if (t1 == typeof(Vector2Surrogate)) {
if (_vector2Plugin == null) _vector2Plugin = new Vector2SurrogatePlugin();
} else if (t1 == typeof(DOVector2)) {
if (_vector2Plugin == null) _vector2Plugin = new DOVector2Plugin();
plugin = _vector2Plugin;
}
#else
else if (t1 == typeof(Vector2)) {
if (_vector2Plugin == null) _vector2Plugin = new Vector2Plugin();
plugin = _vector2Plugin;
}
#endif
else if (t1 == typeof(float)) {
} else if (t1 == typeof(float)) {
if (_floatPlugin == null) _floatPlugin = new FloatPlugin();
plugin = _floatPlugin;
}
#if WP81
else if (t1 == typeof(ColorSurrogate)) {
if (_colorPlugin == null) _colorPlugin = new ColorSurrogatePlugin();
} else if (t1 == typeof(DOColor)) {
if (_colorPlugin == null) _colorPlugin = new DOColorPlugin();
plugin = _colorPlugin;
}
#else
else if (t1 == typeof(Color)) {
if (_colorPlugin == null) _colorPlugin = new ColorPlugin();
plugin = _colorPlugin;
}
#endif
else if (t1 == typeof(int)) {
} else if (t1 == typeof(int)) {
if (_intPlugin == null) _intPlugin = new IntPlugin();
plugin = _intPlugin;
}
#if WP81
else if (t1 == typeof(Vector4Surrogate)) {
if (_vector4Plugin == null) _vector4Plugin = new Vector4SurrogatePlugin();
} else if (t1 == typeof(DOVector4)) {
if (_vector4Plugin == null) _vector4Plugin = new DOVector4Plugin();
plugin = _vector4Plugin;
}
#else
else if (t1 == typeof(Vector4)) {
if (_vector4Plugin == null) _vector4Plugin = new Vector4Plugin();
plugin = _vector4Plugin;
}
#endif
else if (t1 == typeof(Rect)) {
} else if (t1 == typeof(Rect)) {
if (_rectPlugin == null) _rectPlugin = new RectPlugin();
plugin = _rectPlugin;
} else if (t1 == typeof(RectOffset)) {
@ -145,67 +115,7 @@ namespace DG.Tweening.Plugins.Core
plugin = _ulongPlugin;
}
#if !WP81
if (plugin != null) return plugin as ABSTweenPlugin<T1, T2, TPlugOptions>;
#else
if (plugin != null) return plugin as ABSTweenPlugin<T1, T2, TPlugOptions>;
// WP8.1 fix tries
// if (plugin != null) {
// Debug.Log("PLUGIN FOUND, trying to assign it correctly...");
// ABSTweenPlugin<T1, T2, TPlugOptions> p;
// ABSTweenPlugin<Vector3, Vector3, VectorOptions> pExplicit;
// // Explicit casting to Vector3Plugin
// try {
// pExplicit = (ABSTweenPlugin<Vector3, Vector3, VectorOptions>)plugin;
// if (pExplicit != null) Debug.Log("- EXPLICIT CAST SUCCESS X");
// p = pExplicit as ABSTweenPlugin<T1, T2, TPlugOptions>;
// if (p != null) {
// Debug.Log("- PLUGIN SUCCESS X");
// return p;
// }
// } catch (Exception e) {
// Debug.Log("- PLUGIN FAIL X > " + e.Message);
// }
// // More regular ways
// try {
// p = plugin as ABSTweenPlugin<T1, T2, TPlugOptions>;
// if (p != null) {
// Debug.Log("- PLUGIN SUCCESS A");
// return p;
// }
// } catch (Exception e) {
// Debug.Log("- PLUGIN FAIL A > " + e.Message);
// }
// try {
// System.Object obj = (object)plugin;
// p = obj as ABSTweenPlugin<T1, T2, TPlugOptions>;
// if (p != null) {
// Debug.Log("- PLUGIN SUCCESS A2");
// return p;
// }
// } catch (Exception e) {
// Debug.Log("- PLUGIN FAIL A2 > " + e.Message);
// }
// try {
// p = (ABSTweenPlugin<T1, T2, TPlugOptions>)plugin;
// Debug.Log("- PLUGIN SUCCESS B");
// return p;
// } catch (Exception e) {
// Debug.Log("- PLUGIN FAIL B > " + e.Message);
// }
// try {
// System.Object obj = (object)plugin;
// p = (ABSTweenPlugin<T1, T2, TPlugOptions>)obj;
// Debug.Log("- PLUGIN SUCCESS B2");
// return p;
// } catch (Exception e) {
// Debug.Log("- PLUGIN FAIL B2 > " + e.Message);
// }
// return null;
// }
// Debug.Log("PLUGIN NOT FOUND");
// WP8.1 fix tries END
#endif
return null;
}

14
_DOTween.Assembly/DOTween/Plugins/Core/SpecialPluginsUtils.cs
View File

@ -4,8 +4,12 @@
// License Copyright (c) Daniele Giardini.
// This work is subject to the terms at http://dotween.demigiant.com/license.php
#if WP81
using DG.Tweening.Core.Surrogates;
#if COMPATIBLE
using DOVector3 = DG.Tweening.Core.Surrogates.Vector3Wrapper;
using DOQuaternion = DG.Tweening.Core.Surrogates.QuaternionWrapper;
#else
using DOVector3 = UnityEngine.Vector3;
using DOQuaternion = UnityEngine.Quaternion;
#endif
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
@ -17,11 +21,7 @@ namespace DG.Tweening.Plugins.Core
internal static class SpecialPluginsUtils
{
// Returns TRUE if it's successful, FALSE otherwise
#if WP81
internal static bool SetLookAt(TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t)
#else
internal static bool SetLookAt(TweenerCore<Quaternion, Vector3, QuaternionOptions> t)
#endif
internal static bool SetLookAt(TweenerCore<DOQuaternion, DOVector3, QuaternionOptions> t)
{
Transform trans = t.target as Transform;
Vector3 towards = t.endValue;

2
_DOTween.Assembly/DOTween/Plugins/QuaternionPlugin.cs
View File

@ -1,4 +1,4 @@
#if !WP81
#if !COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2014/07/07 20:02
//

111
_DOTween.Assembly/DOTween/Plugins/QuaternionSurrogatePlugin.cs
View File

@ -1,111 +0,0 @@
#if WP81
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/15 12:32
using DG.Tweening.Core;
using DG.Tweening.Core.Easing;
using DG.Tweening.Core.Surrogates;
using DG.Tweening.Plugins.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Plugins
{
public class QuaternionSurrogatePlugin : ABSTweenPlugin<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions>
{
public override void Reset(TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t) { }
public override void SetFrom(TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t, bool isRelative)
{
Vector3Surrogate prevEndVal = t.endValue;
t.endValue = ((Quaternion)t.getter()).eulerAngles;
if (t.plugOptions.rotateMode == RotateMode.Fast && !t.isRelative) {
t.startValue = prevEndVal;
} else if (t.plugOptions.rotateMode == RotateMode.FastBeyond360) {
t.startValue = t.endValue + prevEndVal;
} else {
QuaternionSurrogate rot = t.getter();
if (t.plugOptions.rotateMode == RotateMode.WorldAxisAdd) {
t.startValue = ((Quaternion)rot * Quaternion.Inverse(rot) * Quaternion.Euler(prevEndVal) * (Quaternion)rot).eulerAngles;
} else {
t.startValue = ((Quaternion)rot * Quaternion.Euler(prevEndVal)).eulerAngles;
}
t.endValue = -prevEndVal;
}
t.setter(Quaternion.Euler(t.startValue));
}
public override Vector3Surrogate ConvertToStartValue(TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t, QuaternionSurrogate value)
{
return ((Quaternion)value).eulerAngles;
}
public override void SetRelativeEndValue(TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t)
{
t.endValue += t.startValue;
}
public override void SetChangeValue(TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t)
{
if (t.plugOptions.rotateMode == RotateMode.Fast && !t.isRelative) {
// Rotation will be adapted to 360° and will take the shortest route
// - Adapt to 360°
Vector3Surrogate ev = t.endValue;
if (ev.x > 360) ev.x = ev.x % 360;
if (ev.y > 360) ev.y = ev.y % 360;
if (ev.z > 360) ev.z = ev.z % 360;
Vector3Surrogate changeVal = ev - t.startValue;
// - Find shortest rotation
float abs = (changeVal.x > 0 ? changeVal.x : -changeVal.x);
if (abs > 180) changeVal.x = changeVal.x > 0 ? -(360 - abs) : 360 - abs;
abs = (changeVal.y > 0 ? changeVal.y : -changeVal.y);
if (abs > 180) changeVal.y = changeVal.y > 0 ? -(360 - abs) : 360 - abs;
abs = (changeVal.z > 0 ? changeVal.z : -changeVal.z);
if (abs > 180) changeVal.z = changeVal.z > 0 ? -(360 - abs) : 360 - abs;
// - Assign
t.changeValue = changeVal;
} else if (t.plugOptions.rotateMode == RotateMode.FastBeyond360 || t.isRelative) {
t.changeValue = t.endValue - t.startValue;
} else {
t.changeValue = t.endValue;
}
}
public override float GetSpeedBasedDuration(QuaternionOptions options, float unitsXSecond, Vector3Surrogate changeValue)
{
return changeValue.magnitude / unitsXSecond;
}
public override void EvaluateAndApply(QuaternionOptions options, Tween t, bool isRelative, DOGetter<QuaternionSurrogate> getter, DOSetter<QuaternionSurrogate> setter, float elapsed, Vector3Surrogate startValue, Vector3Surrogate changeValue, float duration, bool usingInversePosition)
{
Vector3Surrogate endValue = startValue;
if (t.loopType == LoopType.Incremental) endValue += changeValue * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental) {
endValue += changeValue * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
float easeVal = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
switch (options.rotateMode) {
case RotateMode.WorldAxisAdd:
case RotateMode.LocalAxisAdd:
QuaternionSurrogate startRot = Quaternion.Euler(startValue); // Reset rotation
endValue.x = changeValue.x * easeVal;
endValue.y = changeValue.y * easeVal;
endValue.z = changeValue.z * easeVal;
if (options.rotateMode == RotateMode.WorldAxisAdd) setter((Quaternion)startRot * Quaternion.Inverse(startRot) * Quaternion.Euler(endValue) * (Quaternion)startRot);
else setter((Quaternion)startRot * Quaternion.Euler(endValue));
break;
default:
endValue.x += changeValue.x * easeVal;
endValue.y += changeValue.y * easeVal;
endValue.z += changeValue.z * easeVal;
setter(Quaternion.Euler(endValue));
break;
}
}
}
}
#endif

111
_DOTween.Assembly/DOTween/Plugins/QuaternionWrapperPlugin.cs Normal file
View File

@ -0,0 +1,111 @@
#if COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/20 18:21
using DG.Tweening.Core;
using DG.Tweening.Core.Easing;
using DG.Tweening.Core.Surrogates;
using DG.Tweening.Plugins.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Plugins
{
public class QuaternionWrapperPlugin : ABSTweenPlugin<QuaternionWrapper, Vector3Wrapper, QuaternionOptions>
{
public override void Reset(TweenerCore<QuaternionWrapper, Vector3Wrapper, QuaternionOptions> t) { }
public override void SetFrom(TweenerCore<QuaternionWrapper, Vector3Wrapper, QuaternionOptions> t, bool isRelative)
{
Vector3 prevEndVal = t.endValue.value;
t.endValue.value = t.getter().value.eulerAngles;
if (t.plugOptions.rotateMode == RotateMode.Fast && !t.isRelative) {
t.startValue.value = prevEndVal;
} else if (t.plugOptions.rotateMode == RotateMode.FastBeyond360) {
t.startValue.value = t.endValue.value + prevEndVal;
} else {
Quaternion rot = t.getter().value;
if (t.plugOptions.rotateMode == RotateMode.WorldAxisAdd) {
t.startValue.value = (rot * Quaternion.Inverse(rot) * Quaternion.Euler(prevEndVal) * rot).eulerAngles;
} else {
t.startValue.value = (rot * Quaternion.Euler(prevEndVal)).eulerAngles;
}
t.endValue.value = -prevEndVal;
}
t.setter(Quaternion.Euler(t.startValue.value));
}
public override Vector3Wrapper ConvertToStartValue(TweenerCore<QuaternionWrapper, Vector3Wrapper, QuaternionOptions> t, QuaternionWrapper value)
{
return value.value.eulerAngles;
}
public override void SetRelativeEndValue(TweenerCore<QuaternionWrapper, Vector3Wrapper, QuaternionOptions> t)
{
t.endValue.value += t.startValue.value;
}
public override void SetChangeValue(TweenerCore<QuaternionWrapper, Vector3Wrapper, QuaternionOptions> t)
{
if (t.plugOptions.rotateMode == RotateMode.Fast && !t.isRelative) {
// Rotation will be adapted to 360° and will take the shortest route
// - Adapt to 360°
Vector3 ev = t.endValue.value;
if (ev.x > 360) ev.x = ev.x % 360;
if (ev.y > 360) ev.y = ev.y % 360;
if (ev.z > 360) ev.z = ev.z % 360;
Vector3 changeVal = ev - t.startValue.value;
// - Find shortest rotation
float abs = (changeVal.x > 0 ? changeVal.x : -changeVal.x);
if (abs > 180) changeVal.x = changeVal.x > 0 ? -(360 - abs) : 360 - abs;
abs = (changeVal.y > 0 ? changeVal.y : -changeVal.y);
if (abs > 180) changeVal.y = changeVal.y > 0 ? -(360 - abs) : 360 - abs;
abs = (changeVal.z > 0 ? changeVal.z : -changeVal.z);
if (abs > 180) changeVal.z = changeVal.z > 0 ? -(360 - abs) : 360 - abs;
// - Assign
t.changeValue.value = changeVal;
} else if (t.plugOptions.rotateMode == RotateMode.FastBeyond360 || t.isRelative) {
t.changeValue.value = t.endValue.value - t.startValue.value;
} else {
t.changeValue.value = t.endValue.value;
}
}
public override float GetSpeedBasedDuration(QuaternionOptions options, float unitsXSecond, Vector3Wrapper changeValue)
{
return changeValue.value.magnitude / unitsXSecond;
}
public override void EvaluateAndApply(QuaternionOptions options, Tween t, bool isRelative, DOGetter<QuaternionWrapper> getter, DOSetter<QuaternionWrapper> setter, float elapsed, Vector3Wrapper startValue, Vector3Wrapper changeValue, float duration, bool usingInversePosition)
{
Vector3 endValue = startValue.value;
if (t.loopType == LoopType.Incremental) endValue += changeValue.value * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental) {
endValue += changeValue.value * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
float easeVal = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
switch (options.rotateMode) {
case RotateMode.WorldAxisAdd:
case RotateMode.LocalAxisAdd:
Quaternion startRot = Quaternion.Euler(startValue.value); // Reset rotation
endValue.x = changeValue.value.x * easeVal;
endValue.y = changeValue.value.y * easeVal;
endValue.z = changeValue.value.z * easeVal;
if (options.rotateMode == RotateMode.WorldAxisAdd) setter(startRot * Quaternion.Inverse(startRot) * Quaternion.Euler(endValue) * startRot);
else setter(startRot * Quaternion.Euler(endValue));
break;
default:
endValue.x += changeValue.value.x * easeVal;
endValue.y += changeValue.value.y * easeVal;
endValue.z += changeValue.value.z * easeVal;
setter(Quaternion.Euler(endValue));
break;
}
}
}
}
#endif

2
_DOTween.Assembly/DOTween/Plugins/Vector2Plugin.cs
View File

@ -1,4 +1,4 @@
#if !WP81
#if !COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2014/07/10 16:51
//

109
_DOTween.Assembly/DOTween/Plugins/Vector2SurrogatePlugin.cs
View File

@ -1,109 +0,0 @@
#if WP81
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/14 12:46
using System;
using DG.Tweening.Core;
using DG.Tweening.Core.Easing;
using DG.Tweening.Core.Surrogates;
using DG.Tweening.Plugins.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Plugins
{
public class Vector2SurrogatePlugin : ABSTweenPlugin<Vector2Surrogate, Vector2Surrogate, VectorOptions>
{
public override void Reset(TweenerCore<Vector2Surrogate, Vector2Surrogate, VectorOptions> t) { }
public override void SetFrom(TweenerCore<Vector2Surrogate, Vector2Surrogate, VectorOptions> t, bool isRelative)
{
Vector2Surrogate prevEndVal = t.endValue;
t.endValue = t.getter();
t.startValue = isRelative ? t.endValue + prevEndVal : prevEndVal;
Vector2Surrogate to = t.endValue;
switch (t.plugOptions.axisConstraint) {
case AxisConstraint.X:
to.x = t.startValue.x;
break;
case AxisConstraint.Y:
to.y = t.startValue.y;
break;
default:
to = t.startValue;
break;
}
if (t.plugOptions.snapping) {
to.x = (float)Math.Round(to.x);
to.y = (float)Math.Round(to.y);
}
t.setter(to);
}
public override Vector2Surrogate ConvertToStartValue(TweenerCore<Vector2Surrogate, Vector2Surrogate, VectorOptions> t, Vector2Surrogate value)
{
return value;
}
public override void SetRelativeEndValue(TweenerCore<Vector2Surrogate, Vector2Surrogate, VectorOptions> t)
{
t.endValue += t.startValue;
}
public override void SetChangeValue(TweenerCore<Vector2Surrogate, Vector2Surrogate, VectorOptions> t)
{
switch (t.plugOptions.axisConstraint) {
case AxisConstraint.X:
t.changeValue = new Vector2Surrogate(t.endValue.x - t.startValue.x, 0);
break;
case AxisConstraint.Y:
t.changeValue = new Vector2Surrogate(0, t.endValue.y - t.startValue.y);
break;
default:
t.changeValue = t.endValue - t.startValue;
break;
}
}
public override float GetSpeedBasedDuration(VectorOptions options, float unitsXSecond, Vector2Surrogate changeValue)
{
return changeValue.magnitude / unitsXSecond;
}
public override void EvaluateAndApply(VectorOptions options, Tween t, bool isRelative, DOGetter<Vector2Surrogate> getter, DOSetter<Vector2Surrogate> setter, float elapsed, Vector2Surrogate startValue, Vector2Surrogate changeValue, float duration, bool usingInversePosition)
{
if (t.loopType == LoopType.Incremental) startValue += changeValue * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental) {
startValue += changeValue * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
float easeVal = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
switch (options.axisConstraint) {
case AxisConstraint.X:
Vector2Surrogate resX = getter();
resX.x = startValue.x + changeValue.x * easeVal;
if (options.snapping) resX.x = (float)Math.Round(resX.x);
setter(resX);
break;
case AxisConstraint.Y:
Vector2Surrogate resY = getter();
resY.y = startValue.y + changeValue.y * easeVal;
if (options.snapping) resY.y = (float)Math.Round(resY.y);
setter(resY);
break;
default:
startValue.x += changeValue.x * easeVal;
startValue.y += changeValue.y * easeVal;
if (options.snapping) {
startValue.x = (float)Math.Round(startValue.x);
startValue.y = (float)Math.Round(startValue.y);
}
setter(startValue);
break;
}
}
}
}
#endif

109
_DOTween.Assembly/DOTween/Plugins/Vector2WrapperPlugin.cs Normal file
View File

@ -0,0 +1,109 @@
#if COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/20 18:06
using System;
using DG.Tweening.Core;
using DG.Tweening.Core.Easing;
using DG.Tweening.Core.Surrogates;
using DG.Tweening.Plugins.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Plugins
{
public class Vector2WrapperPlugin : ABSTweenPlugin<Vector2Wrapper, Vector2Wrapper, VectorOptions>
{
public override void Reset(TweenerCore<Vector2Wrapper, Vector2Wrapper, VectorOptions> t) { }
public override void SetFrom(TweenerCore<Vector2Wrapper, Vector2Wrapper, VectorOptions> t, bool isRelative)
{
Vector2 prevEndVal = t.endValue;
t.endValue = t.getter().value;
t.startValue.value = isRelative ? t.endValue.value + prevEndVal : prevEndVal;
Vector2 to = t.endValue;
switch (t.plugOptions.axisConstraint) {
case AxisConstraint.X:
to.x = t.startValue.value.x;
break;
case AxisConstraint.Y:
to.y = t.startValue.value.y;
break;
default:
to = t.startValue;
break;
}
if (t.plugOptions.snapping) {
to.x = (float)Math.Round(to.x);
to.y = (float)Math.Round(to.y);
}
t.setter(to);
}
public override Vector2Wrapper ConvertToStartValue(TweenerCore<Vector2Wrapper, Vector2Wrapper, VectorOptions> t, Vector2Wrapper value)
{
return value.value;
}
public override void SetRelativeEndValue(TweenerCore<Vector2Wrapper, Vector2Wrapper, VectorOptions> t)
{
t.endValue.value += t.startValue.value;
}
public override void SetChangeValue(TweenerCore<Vector2Wrapper, Vector2Wrapper, VectorOptions> t)
{
switch (t.plugOptions.axisConstraint) {
case AxisConstraint.X:
t.changeValue.value = new Vector2(t.endValue.value.x - t.startValue.value.x, 0);
break;
case AxisConstraint.Y:
t.changeValue.value = new Vector2(0, t.endValue.value.y - t.startValue.value.y);
break;
default:
t.changeValue.value = t.endValue.value - t.startValue.value;
break;
}
}
public override float GetSpeedBasedDuration(VectorOptions options, float unitsXSecond, Vector2Wrapper changeValue)
{
return changeValue.value.magnitude / unitsXSecond;
}
public override void EvaluateAndApply(VectorOptions options, Tween t, bool isRelative, DOGetter<Vector2Wrapper> getter, DOSetter<Vector2Wrapper> setter, float elapsed, Vector2Wrapper startValue, Vector2Wrapper changeValue, float duration, bool usingInversePosition)
{
if (t.loopType == LoopType.Incremental) startValue.value += changeValue.value * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental) {
startValue.value += changeValue.value * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
float easeVal = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
switch (options.axisConstraint) {
case AxisConstraint.X:
Vector2 resX = getter().value;
resX.x = startValue.value.x + changeValue.value.x * easeVal;
if (options.snapping) resX.x = (float)Math.Round(resX.x);
setter(resX);
break;
case AxisConstraint.Y:
Vector2 resY = getter().value;
resY.y = startValue.value.y + changeValue.value.y * easeVal;
if (options.snapping) resY.y = (float)Math.Round(resY.y);
setter(resY);
break;
default:
startValue.value.x += changeValue.value.x * easeVal;
startValue.value.y += changeValue.value.y * easeVal;
if (options.snapping) {
startValue.value.x = (float)Math.Round(startValue.value.x);
startValue.value.y = (float)Math.Round(startValue.value.y);
}
setter(startValue);
break;
}
}
}
}
#endif

2
_DOTween.Assembly/DOTween/Plugins/Vector3Plugin.cs
View File

@ -1,4 +1,4 @@
#if !WP81
#if !COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2014/05/06 19:35
//

123
_DOTween.Assembly/DOTween/Plugins/Vector3SurrogatePlugin.cs
View File

@ -1,123 +0,0 @@
#if WP81
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/14 12:44
using System;
using DG.Tweening.Core;
using DG.Tweening.Core.Easing;
using DG.Tweening.Core.Surrogates;
using DG.Tweening.Plugins.Core;
using DG.Tweening.Plugins.Options;
#pragma warning disable 1591
namespace DG.Tweening.Plugins
{
public class Vector3SurrogatePlugin : ABSTweenPlugin<Vector3Surrogate, Vector3Surrogate, VectorOptions>
{
public override void Reset(TweenerCore<Vector3Surrogate, Vector3Surrogate, VectorOptions> t) { }
public override void SetFrom(TweenerCore<Vector3Surrogate, Vector3Surrogate, VectorOptions> t, bool isRelative)
{
Vector3Surrogate prevEndVal = t.endValue;
t.endValue = t.getter();
t.startValue = isRelative ? t.endValue + prevEndVal : prevEndVal;
Vector3Surrogate to = t.endValue;
switch (t.plugOptions.axisConstraint) {
case AxisConstraint.X:
to.x = t.startValue.x;
break;
case AxisConstraint.Y:
to.y = t.startValue.y;
break;
case AxisConstraint.Z:
to.z = t.startValue.z;
break;
default:
to = t.startValue;
break;
}
if (t.plugOptions.snapping) {
to.x = (float)Math.Round(to.x);
to.y = (float)Math.Round(to.y);
to.z = (float)Math.Round(to.z);
}
t.setter(to);
}
public override Vector3Surrogate ConvertToStartValue(TweenerCore<Vector3Surrogate, Vector3Surrogate, VectorOptions> t, Vector3Surrogate value)
{
return value;
}
public override void SetRelativeEndValue(TweenerCore<Vector3Surrogate, Vector3Surrogate, VectorOptions> t)
{
t.endValue += t.startValue;
}
public override void SetChangeValue(TweenerCore<Vector3Surrogate, Vector3Surrogate, VectorOptions> t)
{
switch (t.plugOptions.axisConstraint) {
case AxisConstraint.X:
t.changeValue = new Vector3Surrogate(t.endValue.x - t.startValue.x, 0, 0);
break;
case AxisConstraint.Y:
t.changeValue = new Vector3Surrogate(0, t.endValue.y - t.startValue.y, 0);
break;
case AxisConstraint.Z:
t.changeValue = new Vector3Surrogate(0, 0, t.endValue.z - t.startValue.z);
break;
default:
t.changeValue = t.endValue - t.startValue;
break;
}
}
public override float GetSpeedBasedDuration(VectorOptions options, float unitsXSecond, Vector3Surrogate changeValue)
{
return changeValue.magnitude / unitsXSecond;
}
public override void EvaluateAndApply(VectorOptions options, Tween t, bool isRelative, DOGetter<Vector3Surrogate> getter, DOSetter<Vector3Surrogate> setter, float elapsed, Vector3Surrogate startValue, Vector3Surrogate changeValue, float duration, bool usingInversePosition)
{
if (t.loopType == LoopType.Incremental) startValue += changeValue * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental) {
startValue += changeValue * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
float easeVal = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
switch (options.axisConstraint) {
case AxisConstraint.X:
Vector3Surrogate resX = getter();
resX.x = startValue.x + changeValue.x * easeVal;
if (options.snapping) resX.x = (float)Math.Round(resX.x);
setter(resX);
break;
case AxisConstraint.Y:
Vector3Surrogate resY = getter();
resY.y = startValue.y + changeValue.y * easeVal;
if (options.snapping) resY.y = (float)Math.Round(resY.y);
setter(resY);
break;
case AxisConstraint.Z:
Vector3Surrogate resZ = getter();
resZ.z = startValue.z + changeValue.z * easeVal;
if (options.snapping) resZ.z = (float)Math.Round(resZ.z);
setter(resZ);
break;
default:
startValue.x += changeValue.x * easeVal;
startValue.y += changeValue.y * easeVal;
startValue.z += changeValue.z * easeVal;
if (options.snapping) {
startValue.x = (float)Math.Round(startValue.x);
startValue.y = (float)Math.Round(startValue.y);
startValue.z = (float)Math.Round(startValue.z);
}
setter(startValue);
break;
}
}
}
}
#endif

124
_DOTween.Assembly/DOTween/Plugins/Vector3WrapperPlugin.cs Normal file
View File

@ -0,0 +1,124 @@
#if COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/20 16:59
using System;
using DG.Tweening.Core;
using DG.Tweening.Core.Easing;
using DG.Tweening.Core.Surrogates;
using DG.Tweening.Plugins.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Plugins
{
public class Vector3WrapperPlugin : ABSTweenPlugin<Vector3Wrapper, Vector3Wrapper, VectorOptions>
{
public override void Reset(TweenerCore<Vector3Wrapper, Vector3Wrapper, VectorOptions> t) { }
public override void SetFrom(TweenerCore<Vector3Wrapper, Vector3Wrapper, VectorOptions> t, bool isRelative)
{
Vector3 prevEndVal = t.endValue;
t.endValue = t.getter().value;
t.startValue.value = isRelative ? t.endValue.value + prevEndVal : prevEndVal;
Vector3 to = t.endValue;
switch (t.plugOptions.axisConstraint) {
case AxisConstraint.X:
to.x = t.startValue.value.x;
break;
case AxisConstraint.Y:
to.y = t.startValue.value.y;
break;
case AxisConstraint.Z:
to.z = t.startValue.value.z;
break;
default:
to = t.startValue;
break;
}
if (t.plugOptions.snapping) {
to.x = (float)Math.Round(to.x);
to.y = (float)Math.Round(to.y);
to.z = (float)Math.Round(to.z);
}
t.setter(to);
}
public override Vector3Wrapper ConvertToStartValue(TweenerCore<Vector3Wrapper, Vector3Wrapper, VectorOptions> t, Vector3Wrapper value)
{
return value.value;
}
public override void SetRelativeEndValue(TweenerCore<Vector3Wrapper, Vector3Wrapper, VectorOptions> t)
{
t.endValue.value += t.startValue.value;
}
public override void SetChangeValue(TweenerCore<Vector3Wrapper, Vector3Wrapper, VectorOptions> t)
{
switch (t.plugOptions.axisConstraint) {
case AxisConstraint.X:
t.changeValue.value = new Vector3(t.endValue.value.x - t.startValue.value.x, 0, 0);
break;
case AxisConstraint.Y:
t.changeValue.value = new Vector3(0, t.endValue.value.y - t.startValue.value.y, 0);
break;
case AxisConstraint.Z:
t.changeValue.value = new Vector3(0, 0, t.endValue.value.z - t.startValue.value.z);
break;
default:
t.changeValue.value = t.endValue.value - t.startValue.value;
break;
}
}
public override float GetSpeedBasedDuration(VectorOptions options, float unitsXSecond, Vector3Wrapper changeValue)
{
return changeValue.value.magnitude / unitsXSecond;
}
public override void EvaluateAndApply(VectorOptions options, Tween t, bool isRelative, DOGetter<Vector3Wrapper> getter, DOSetter<Vector3Wrapper> setter, float elapsed, Vector3Wrapper startValue, Vector3Wrapper changeValue, float duration, bool usingInversePosition)
{
if (t.loopType == LoopType.Incremental) startValue.value += changeValue.value * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental) {
startValue.value += changeValue.value * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
float easeVal = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
switch (options.axisConstraint) {
case AxisConstraint.X:
Vector3 resX = getter().value;
resX.x = startValue.value.x + changeValue.value.x * easeVal;
if (options.snapping) resX.x = (float)Math.Round(resX.x);
setter(resX);
break;
case AxisConstraint.Y:
Vector3 resY = getter().value;
resY.y = startValue.value.y + changeValue.value.y * easeVal;
if (options.snapping) resY.y = (float)Math.Round(resY.y);
setter(resY);
break;
case AxisConstraint.Z:
Vector3 resZ = getter().value;
resZ.z = startValue.value.z + changeValue.value.z * easeVal;
if (options.snapping) resZ.z = (float)Math.Round(resZ.z);
setter(resZ);
break;
default:
startValue.value.x += changeValue.value.x * easeVal;
startValue.value.y += changeValue.value.y * easeVal;
startValue.value.z += changeValue.value.z * easeVal;
if (options.snapping) {
startValue.value.x = (float)Math.Round(startValue.value.x);
startValue.value.y = (float)Math.Round(startValue.value.y);
startValue.value.z = (float)Math.Round(startValue.value.z);
}
setter(startValue);
break;
}
}
}
}
#endif

2
_DOTween.Assembly/DOTween/Plugins/Vector4Plugin.cs
View File

@ -1,4 +1,4 @@
#if !WP81
#if !COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2014/07/10 16:53
//

139
_DOTween.Assembly/DOTween/Plugins/Vector4SurrogatePlugin.cs
View File

@ -1,139 +0,0 @@
#if WP81
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/14 12:19
using System;
using DG.Tweening.Core;
using DG.Tweening.Core.Easing;
using DG.Tweening.Core.Surrogates;
using DG.Tweening.Plugins.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Plugins
{
public class Vector4SurrogatePlugin : ABSTweenPlugin<Vector4Surrogate, Vector4Surrogate, VectorOptions>
{
public override void Reset(TweenerCore<Vector4Surrogate, Vector4Surrogate, VectorOptions> t) { }
public override void SetFrom(TweenerCore<Vector4Surrogate, Vector4Surrogate, VectorOptions> t, bool isRelative)
{
Vector4Surrogate prevEndVal = t.endValue;
t.endValue = t.getter();
t.startValue = isRelative ? t.endValue + prevEndVal : prevEndVal;
Vector4Surrogate to = t.endValue;
switch (t.plugOptions.axisConstraint) {
case AxisConstraint.X:
to.x = t.startValue.x;
break;
case AxisConstraint.Y:
to.y = t.startValue.y;
break;
case AxisConstraint.Z:
to.z = t.startValue.z;
break;
case AxisConstraint.W:
to.w = t.startValue.w;
break;
default:
to = t.startValue;
break;
}
if (t.plugOptions.snapping) {
to.x = (float)Math.Round(to.x);
to.y = (float)Math.Round(to.y);
to.z = (float)Math.Round(to.z);
to.w = (float)Math.Round(to.w);
}
t.setter(to);
}
public override Vector4Surrogate ConvertToStartValue(TweenerCore<Vector4Surrogate, Vector4Surrogate, VectorOptions> t, Vector4Surrogate value)
{
return value;
}
public override void SetRelativeEndValue(TweenerCore<Vector4Surrogate, Vector4Surrogate, VectorOptions> t)
{
t.endValue += t.startValue;
}
public override void SetChangeValue(TweenerCore<Vector4Surrogate, Vector4Surrogate, VectorOptions> t)
{
switch (t.plugOptions.axisConstraint) {
case AxisConstraint.X:
t.changeValue = new Vector4Surrogate(t.endValue.x - t.startValue.x, 0, 0, 0);
break;
case AxisConstraint.Y:
t.changeValue = new Vector4Surrogate(0, t.endValue.y - t.startValue.y, 0, 0);
break;
case AxisConstraint.Z:
t.changeValue = new Vector4Surrogate(0, 0, t.endValue.z - t.startValue.z, 0);
break;
case AxisConstraint.W:
t.changeValue = new Vector4Surrogate(0, 0, 0, t.endValue.w - t.startValue.w);
break;
default:
t.changeValue = t.endValue - t.startValue;
break;
}
}
public override float GetSpeedBasedDuration(VectorOptions options, float unitsXSecond, Vector4Surrogate changeValue)
{
return changeValue.magnitude / unitsXSecond;
}
public override void EvaluateAndApply(VectorOptions options, Tween t, bool isRelative, DOGetter<Vector4Surrogate> getter, DOSetter<Vector4Surrogate> setter, float elapsed, Vector4Surrogate startValue, Vector4Surrogate changeValue, float duration, bool usingInversePosition)
{
if (t.loopType == LoopType.Incremental) startValue += changeValue * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental) {
startValue += changeValue * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
float easeVal = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
switch (options.axisConstraint) {
case AxisConstraint.X:
Vector4Surrogate resX = getter();
resX.x = startValue.x + changeValue.x * easeVal;
if (options.snapping) resX.x = (float)Math.Round(resX.x);
setter(resX);
break;
case AxisConstraint.Y:
Vector4Surrogate resY = getter();
resY.y = startValue.y + changeValue.y * easeVal;
if (options.snapping) resY.y = (float)Math.Round(resY.y);
setter(resY);
break;
case AxisConstraint.Z:
Vector4Surrogate resZ = getter();
resZ.z = startValue.z + changeValue.z * easeVal;
if (options.snapping) resZ.z = (float)Math.Round(resZ.z);
setter(resZ);
break;
case AxisConstraint.W:
Vector4Surrogate resW = getter();
resW.w = startValue.w + changeValue.w * easeVal;
if (options.snapping) resW.w = (float)Math.Round(resW.w);
setter(resW);
break;
default:
startValue.x += changeValue.x * easeVal;
startValue.y += changeValue.y * easeVal;
startValue.z += changeValue.z * easeVal;
startValue.w += changeValue.w * easeVal;
if (options.snapping) {
startValue.x = (float)Math.Round(startValue.x);
startValue.y = (float)Math.Round(startValue.y);
startValue.z = (float)Math.Round(startValue.z);
startValue.w = (float)Math.Round(startValue.w);
}
setter(startValue);
break;
}
}
}
}
#endif

138
_DOTween.Assembly/DOTween/Plugins/Vector4WrapperPlugin.cs Normal file
View File

@ -0,0 +1,138 @@
#if COMPATIBLE
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/04/20 18:13
using System;
using DG.Tweening.Core;
using DG.Tweening.Core.Easing;
using DG.Tweening.Core.Surrogates;
using DG.Tweening.Plugins.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening.Plugins
{
public class Vector4WrapperPlugin : ABSTweenPlugin<Vector4Wrapper, Vector4Wrapper, VectorOptions>
{
public override void Reset(TweenerCore<Vector4Wrapper, Vector4Wrapper, VectorOptions> t) { }
public override void SetFrom(TweenerCore<Vector4Wrapper, Vector4Wrapper, VectorOptions> t, bool isRelative)
{
Vector4 prevEndVal = t.endValue;
t.endValue = t.getter().value;
t.startValue = isRelative ? t.endValue + prevEndVal : prevEndVal;
Vector4 to = t.endValue;
switch (t.plugOptions.axisConstraint) {
case AxisConstraint.X:
to.x = t.startValue.value.x;
break;
case AxisConstraint.Y:
to.y = t.startValue.value.y;
break;
case AxisConstraint.Z:
to.z = t.startValue.value.z;
break;
case AxisConstraint.W:
to.w = t.startValue.value.w;
break;
default:
to = t.startValue;
break;
}
if (t.plugOptions.snapping) {
to.x = (float)Math.Round(to.x);
to.y = (float)Math.Round(to.y);
to.z = (float)Math.Round(to.z);
to.w = (float)Math.Round(to.w);
}
t.setter(to);
}
public override Vector4Wrapper ConvertToStartValue(TweenerCore<Vector4Wrapper, Vector4Wrapper, VectorOptions> t, Vector4Wrapper value)
{
return value.value;
}
public override void SetRelativeEndValue(TweenerCore<Vector4Wrapper, Vector4Wrapper, VectorOptions> t)
{
t.endValue.value += t.startValue.value;
}
public override void SetChangeValue(TweenerCore<Vector4Wrapper, Vector4Wrapper, VectorOptions> t)
{
switch (t.plugOptions.axisConstraint) {
case AxisConstraint.X:
t.changeValue.value = new Vector4(t.endValue.value.x - t.startValue.value.x, 0, 0, 0);
break;
case AxisConstraint.Y:
t.changeValue.value = new Vector4(0, t.endValue.value.y - t.startValue.value.y, 0, 0);
break;
case AxisConstraint.Z:
t.changeValue.value = new Vector4(0, 0, t.endValue.value.z - t.startValue.value.z, 0);
break;
case AxisConstraint.W:
t.changeValue.value = new Vector4(0, 0, 0, t.endValue.value.w - t.startValue.value.w);
break;
default:
t.changeValue.value = t.endValue.value - t.startValue.value;
break;
}
}
public override float GetSpeedBasedDuration(VectorOptions options, float unitsXSecond, Vector4Wrapper changeValue)
{
return changeValue.value.magnitude / unitsXSecond;
}
public override void EvaluateAndApply(VectorOptions options, Tween t, bool isRelative, DOGetter<Vector4Wrapper> getter, DOSetter<Vector4Wrapper> setter, float elapsed, Vector4Wrapper startValue, Vector4Wrapper changeValue, float duration, bool usingInversePosition)
{
if (t.loopType == LoopType.Incremental) startValue.value += changeValue.value * (t.isComplete ? t.completedLoops - 1 : t.completedLoops);
if (t.isSequenced && t.sequenceParent.loopType == LoopType.Incremental) {
startValue.value += changeValue.value * (t.loopType == LoopType.Incremental ? t.loops : 1)
* (t.sequenceParent.isComplete ? t.sequenceParent.completedLoops - 1 : t.sequenceParent.completedLoops);
}
float easeVal = EaseManager.Evaluate(t.easeType, t.customEase, elapsed, duration, t.easeOvershootOrAmplitude, t.easePeriod);
switch (options.axisConstraint) {
case AxisConstraint.X:
Vector4 resX = getter().value;
resX.x = startValue.value.x + changeValue.value.x * easeVal;
if (options.snapping) resX.x = (float)Math.Round(resX.x);
setter(resX);
break;
case AxisConstraint.Y:
Vector4 resY = getter().value;
resY.y = startValue.value.y + changeValue.value.y * easeVal;
if (options.snapping) resY.y = (float)Math.Round(resY.y);
setter(resY);
break;
case AxisConstraint.Z:
Vector4 resZ = getter().value;
resZ.z = startValue.value.z + changeValue.value.z * easeVal;
if (options.snapping) resZ.z = (float)Math.Round(resZ.z);
setter(resZ);
break;
case AxisConstraint.W:
Vector4 resW = getter().value;
resW.w = startValue.value.w + changeValue.value.w * easeVal;
if (options.snapping) resW.w = (float)Math.Round(resW.w);
setter(resW);
break;
default:
startValue.value.x += changeValue.value.x * easeVal;
startValue.value.y += changeValue.value.y * easeVal;
startValue.value.z += changeValue.value.z * easeVal;
startValue.value.w += changeValue.value.w * easeVal;
if (options.snapping) {
startValue.value.x = (float)Math.Round(startValue.value.x);
startValue.value.y = (float)Math.Round(startValue.value.y);
startValue.value.z = (float)Math.Round(startValue.value.z);
startValue.value.w = (float)Math.Round(startValue.value.w);
}
setter(startValue);
break;
}
}
}
}
#endif

134
_DOTween.Assembly/DOTween/ShortcutExtensions.cs
View File

@ -4,10 +4,14 @@
// License Copyright (c) Daniele Giardini.
// This work is subject to the terms at http://dotween.demigiant.com/license.php
#if WP81
#if COMPATIBLE
using DG.Tweening.Core.Surrogates;
using DOVector3 = DG.Tweening.Core.Surrogates.Vector3Wrapper;
using DOQuaternion = DG.Tweening.Core.Surrogates.QuaternionWrapper;
#else
using DOVector3 = UnityEngine.Vector3;
using DOQuaternion = UnityEngine.Quaternion;
#endif
using System.Collections.Generic;
using DG.Tweening.Core;
using DG.Tweening.Core.Enums;
using DG.Tweening.Plugins;
@ -238,8 +242,8 @@ namespace DG.Tweening
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOMove(this Rigidbody target, Vector3 endValue, float duration, bool snapping = false)
{
#if WP81
return DOTween.To(() => target.position, x=> target.MovePosition(x), endValue, duration)
#if COMPATIBLE
return DOTween.To(() => target.position, x=> target.MovePosition(x.value), endValue, duration)
#else
return DOTween.To(() => target.position, target.MovePosition, endValue, duration)
#endif
@ -252,8 +256,8 @@ namespace DG.Tweening
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOMoveX(this Rigidbody target, float endValue, float duration, bool snapping = false)
{
#if WP81
return DOTween.To(() => target.position, x => target.MovePosition(x), new Vector3(endValue, 0, 0), duration)
#if COMPATIBLE
return DOTween.To(() => target.position, x => target.MovePosition(x.value), new Vector3(endValue, 0, 0), duration)
#else
return DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue, 0, 0), duration)
#endif
@ -266,8 +270,8 @@ namespace DG.Tweening
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOMoveY(this Rigidbody target, float endValue, float duration, bool snapping = false)
{
#if WP81
return DOTween.To(() => target.position, x => target.MovePosition(x), new Vector3(0, endValue, 0), duration)
#if COMPATIBLE
return DOTween.To(() => target.position, x => target.MovePosition(x.value), new Vector3(0, endValue, 0), duration)
#else
return DOTween.To(() => target.position, target.MovePosition, new Vector3(0, endValue, 0), duration)
#endif
@ -280,8 +284,8 @@ namespace DG.Tweening
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOMoveZ(this Rigidbody target, float endValue, float duration, bool snapping = false)
{
#if WP81
return DOTween.To(() => target.position, x => target.MovePosition(x), new Vector3(0, 0, endValue), duration)
#if COMPATIBLE
return DOTween.To(() => target.position, x => target.MovePosition(x.value), new Vector3(0, 0, endValue), duration)
#else
return DOTween.To(() => target.position, target.MovePosition, new Vector3(0, 0, endValue), duration)
#endif
@ -294,8 +298,8 @@ namespace DG.Tweening
/// <param name="mode">Rotation mode</param>
public static Tweener DORotate(this Rigidbody target, Vector3 endValue, float duration, RotateMode mode = RotateMode.Fast)
{
#if WP81
TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t = DOTween.To(() => target.rotation, x => target.MoveRotation(x), endValue, duration);
#if COMPATIBLE
TweenerCore<QuaternionWrapper, Vector3Wrapper, QuaternionOptions> t = DOTween.To(() => target.rotation, x => target.MoveRotation(x), endValue, duration);
#else
TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration);
#endif
@ -311,8 +315,8 @@ namespace DG.Tweening
/// <param name="up">The vector that defines in which direction up is (default: Vector3.up)</param>
public static Tweener DOLookAt(this Rigidbody target, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3? up = null)
{
#if WP81
TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t = DOTween.To(() => target.rotation, x => target.MoveRotation(x), towards, duration)
#if COMPATIBLE
TweenerCore<QuaternionWrapper, Vector3Wrapper, QuaternionOptions> t = DOTween.To(() => target.rotation, x => target.MoveRotation(x), towards, duration)
#else
TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, towards, duration)
#endif
@ -333,8 +337,13 @@ namespace DG.Tweening
public static Tweener DOResize(this TrailRenderer target, float toStartWidth, float toEndWidth, float duration)
{
return DOTween.To(() => new Vector2(target.startWidth, target.endWidth), x => {
#if COMPATIBLE
target.startWidth = x.value.x;
target.endWidth = x.value.y;
#else
target.startWidth = x.x;
target.endWidth = x.y;
#endif
}, new Vector2(toStartWidth, toEndWidth), duration)
.SetTarget(target);
}
@ -438,11 +447,7 @@ namespace DG.Tweening
/// <param name="mode">Rotation mode</param>
public static Tweener DORotate(this Transform target, Vector3 endValue, float duration, RotateMode mode = RotateMode.Fast)
{
#if WP81
TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t = DOTween.To(() => target.rotation, x => target.rotation = x, endValue, duration);
#else
TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.rotation, x => target.rotation = x, endValue, duration);
#endif
TweenerCore<DOQuaternion, DOVector3, QuaternionOptions> t = DOTween.To(() => target.rotation, x => target.rotation = x, endValue, duration);
t.SetTarget(target);
t.plugOptions.rotateMode = mode;
return t;
@ -454,11 +459,7 @@ namespace DG.Tweening
/// <param name="mode">Rotation mode</param>
public static Tweener DOLocalRotate(this Transform target, Vector3 endValue, float duration, RotateMode mode = RotateMode.Fast)
{
#if WP81
TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t = DOTween.To(() => target.localRotation, x => target.localRotation = x, endValue, duration);
#else
TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.localRotation, x => target.localRotation = x, endValue, duration);
#endif
TweenerCore<DOQuaternion, DOVector3, QuaternionOptions> t = DOTween.To(() => target.localRotation, x => target.localRotation = x, endValue, duration);
t.SetTarget(target);
t.plugOptions.rotateMode = mode;
return t;
@ -518,11 +519,7 @@ namespace DG.Tweening
/// <param name="up">The vector that defines in which direction up is (default: Vector3.up)</param>
public static Tweener DOLookAt(this Transform target, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3? up = null)
{
#if WP81
TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t = DOTween.To(() => target.rotation, x => target.rotation = x, towards, duration)
#else
TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.rotation, x => target.rotation = x, towards, duration)
#endif
TweenerCore<DOQuaternion, DOVector3, QuaternionOptions> t = DOTween.To(() => target.rotation, x => target.rotation = x, towards, duration)
.SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetLookAt);
t.plugOptions.axisConstraint = axisConstraint;
t.plugOptions.up = (up == null) ? Vector3.up : (Vector3)up;
@ -717,13 +714,13 @@ namespace DG.Tweening
public static Tweener DOBlendableColor(this Light target, Color endValue, float duration)
{
endValue = endValue - target.color;
#if WP81
ColorSurrogate to = new ColorSurrogate(0, 0, 0, 0);
#else
Color to = new Color(0, 0, 0, 0);
#endif
return DOTween.To(() => to, x => {
#if COMPATIBLE
Color diff = x.value - to;
#else
Color diff = x - to;
#endif
to = x;
target.color += diff;
}, endValue, duration)
@ -742,13 +739,13 @@ namespace DG.Tweening
public static Tweener DOBlendableColor(this Material target, Color endValue, float duration)
{
endValue = endValue - target.color;
#if WP81
ColorSurrogate to = new ColorSurrogate(0, 0, 0, 0);
#else
Color to = new Color(0, 0, 0, 0);
#endif
return DOTween.To(() => to, x => {
#if COMPATIBLE
Color diff = x.value - to;
#else
Color diff = x - to;
#endif
to = x;
target.color += diff;
}, endValue, duration)
@ -769,13 +766,13 @@ namespace DG.Tweening
}
endValue = endValue - target.color;
#if WP81
ColorSurrogate to = new ColorSurrogate(0, 0, 0, 0);
#else
Color to = new Color(0, 0, 0, 0);
#endif
return DOTween.To(() => to, x => {
#if COMPATIBLE
Color diff = x.value - to;
#else
Color diff = x - to;
#endif
to = x;
target.SetColor(property, target.GetColor(property) + diff);
}, endValue, duration)
@ -794,21 +791,16 @@ namespace DG.Tweening
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOBlendableMoveBy(this Transform target, Vector3 byValue, float duration, bool snapping = false)
{
#if WP81
Vector3Surrogate to = Vector3Surrogate.zero;
return DOTween.To(() => to, x => {
Vector3 diff = x - to;
to = x;
target.position += diff;
}, byValue, duration)
#else
Vector3 to = Vector3.zero;
return DOTween.To(() => to, x => {
#if COMPATIBLE
Vector3 diff = x.value - to;
#else
Vector3 diff = x - to;
#endif
to = x;
target.position += diff;
}, byValue, duration)
#endif
.Blendable().SetOptions(snapping).SetTarget(target);
}
@ -820,21 +812,16 @@ namespace DG.Tweening
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOBlendableLocalMoveBy(this Transform target, Vector3 byValue, float duration, bool snapping = false)
{
#if WP81
Vector3Surrogate to = Vector3Surrogate.zero;
return DOTween.To(() => to, x => {
Vector3 diff = x - to;
to = x;
target.localPosition += diff;
}, byValue, duration)
#else
Vector3 to = Vector3.zero;
return DOTween.To(() => to, x => {
#if COMPATIBLE
Vector3 diff = x.value - to;
#else
Vector3 diff = x - to;
#endif
to = x;
target.localPosition += diff;
}, byValue, duration)
#endif
.Blendable().SetOptions(snapping).SetTarget(target);
}
@ -847,12 +834,12 @@ namespace DG.Tweening
public static Tweener DOBlendableRotateBy(this Transform target, Vector3 byValue, float duration, RotateMode mode = RotateMode.Fast)
{
Quaternion to = target.rotation;
#if WP81
TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t = DOTween.To(() => to, x => {
TweenerCore<DOQuaternion, DOVector3, QuaternionOptions> t = DOTween.To(() => to, x => {
#if COMPATIBLE
Quaternion diff = x.value * Quaternion.Inverse(to);
#else
TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => to, x => {
Quaternion diff = x * Quaternion.Inverse(to);
#endif
Quaternion diff = (Quaternion)x * Quaternion.Inverse(to);
to = x;
target.rotation = target.rotation * Quaternion.Inverse(target.rotation) * diff * target.rotation;
}, byValue, duration)
@ -870,12 +857,12 @@ namespace DG.Tweening
public static Tweener DOBlendableLocalRotateBy(this Transform target, Vector3 byValue, float duration, RotateMode mode = RotateMode.Fast)
{
Quaternion to = target.localRotation;
#if WP81
TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t = DOTween.To(() => to, x => {
TweenerCore<DOQuaternion, DOVector3, QuaternionOptions> t = DOTween.To(() => to, x => {
#if COMPATIBLE
Quaternion diff = x.value * Quaternion.Inverse(to);
#else
TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => to, x => {
Quaternion diff = x * Quaternion.Inverse(to);
#endif
Quaternion diff = (Quaternion)x * Quaternion.Inverse(to);
to = x;
target.localRotation = target.localRotation * Quaternion.Inverse(target.localRotation) * diff * target.localRotation;
}, byValue, duration)
@ -891,21 +878,16 @@ namespace DG.Tweening
/// <param name="byValue">The value to tween by</param><param name="duration">The duration of the tween</param>
public static Tweener DOBlendableScaleBy(this Transform target, Vector3 byValue, float duration)
{
#if WP81
Vector3Surrogate to = Vector3Surrogate.zero;
return DOTween.To(() => to, x => {
Vector3 diff = x - to;
to = x;
target.localScale += diff;
}, byValue, duration)
#else
Vector3 to = Vector3.zero;
return DOTween.To(() => to, x => {
#if COMPATIBLE
Vector3 diff = x.value - to;
#else
Vector3 diff = x - to;
#endif
to = x;
target.localScale += diff;
}, byValue, duration)
#endif
.Blendable().SetTarget(target);
}

62
_DOTween.Assembly/DOTween/TweenSettingsExtensions.cs
View File

@ -4,8 +4,18 @@
// License Copyright (c) Daniele Giardini.
// This work is subject to the terms at http://dotween.demigiant.com/license.php
#if WP81
using DG.Tweening.Core.Surrogates;
#if COMPATIBLE
using DOVector2 = DG.Tweening.Core.Surrogates.Vector2Wrapper;
using DOVector3 = DG.Tweening.Core.Surrogates.Vector3Wrapper;
using DOVector4 = DG.Tweening.Core.Surrogates.Vector4Wrapper;
using DOQuaternion = DG.Tweening.Core.Surrogates.QuaternionWrapper;
using DOColor = DG.Tweening.Core.Surrogates.ColorWrapper;
#else
using DOVector2 = UnityEngine.Vector2;
using DOVector3 = UnityEngine.Vector3;
using DOVector4 = UnityEngine.Vector4;
using DOQuaternion = UnityEngine.Quaternion;
using DOColor = UnityEngine.Color;
#endif
using DG.Tweening.Core;
using DG.Tweening.Core.Easing;
@ -584,11 +594,7 @@ namespace DG.Tweening
/// <summary>Options for Vector2 tweens</summary>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
#if WP81
public static Tweener SetOptions(this TweenerCore<Vector2Surrogate, Vector2Surrogate, VectorOptions> t, bool snapping)
#else
public static Tweener SetOptions(this TweenerCore<Vector2, Vector2, VectorOptions> t, bool snapping)
#endif
public static Tweener SetOptions(this TweenerCore<DOVector2, DOVector2, VectorOptions> t, bool snapping)
{
if (t == null || !t.active) return t;
@ -598,11 +604,7 @@ namespace DG.Tweening
/// <summary>Options for Vector2 tweens</summary>
/// <param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
#if WP81
public static Tweener SetOptions(this TweenerCore<Vector2Surrogate, Vector2Surrogate, VectorOptions> t, AxisConstraint axisConstraint, bool snapping = false)
#else
public static Tweener SetOptions(this TweenerCore<Vector2, Vector2, VectorOptions> t, AxisConstraint axisConstraint, bool snapping = false)
#endif
public static Tweener SetOptions(this TweenerCore<DOVector2, DOVector2, VectorOptions> t, AxisConstraint axisConstraint, bool snapping = false)
{
if (t == null || !t.active) return t;
@ -613,11 +615,7 @@ namespace DG.Tweening
/// <summary>Options for Vector3 tweens</summary>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
#if WP81
public static Tweener SetOptions(this TweenerCore<Vector3Surrogate, Vector3Surrogate, VectorOptions> t, bool snapping)
#else
public static Tweener SetOptions(this TweenerCore<Vector3, Vector3, VectorOptions> t, bool snapping)
#endif
public static Tweener SetOptions(this TweenerCore<DOVector3, DOVector3, VectorOptions> t, bool snapping)
{
if (t == null || !t.active) return t;
@ -627,11 +625,7 @@ namespace DG.Tweening
/// <summary>Options for Vector3 tweens</summary>
/// <param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
#if WP81
public static Tweener SetOptions(this TweenerCore<Vector3Surrogate, Vector3Surrogate, VectorOptions> t, AxisConstraint axisConstraint, bool snapping = false)
#else
public static Tweener SetOptions(this TweenerCore<Vector3, Vector3, VectorOptions> t, AxisConstraint axisConstraint, bool snapping = false)
#endif
public static Tweener SetOptions(this TweenerCore<DOVector3, DOVector3, VectorOptions> t, AxisConstraint axisConstraint, bool snapping = false)
{
if (t == null || !t.active) return t;
@ -642,11 +636,7 @@ namespace DG.Tweening
/// <summary>Options for Vector4 tweens</summary>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
#if WP81
public static Tweener SetOptions(this TweenerCore<Vector4Surrogate, Vector4Surrogate, VectorOptions> t, bool snapping)
#else
public static Tweener SetOptions(this TweenerCore<Vector4, Vector4, VectorOptions> t, bool snapping)
#endif
public static Tweener SetOptions(this TweenerCore<DOVector4, DOVector4, VectorOptions> t, bool snapping)
{
if (t == null || !t.active) return t;
@ -656,11 +646,7 @@ namespace DG.Tweening
/// <summary>Options for Vector4 tweens</summary>
/// <param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
#if WP81
public static Tweener SetOptions(this TweenerCore<Vector4Surrogate, Vector4Surrogate, VectorOptions> t, AxisConstraint axisConstraint, bool snapping = false)
#else
public static Tweener SetOptions(this TweenerCore<Vector4, Vector4, VectorOptions> t, AxisConstraint axisConstraint, bool snapping = false)
#endif
public static Tweener SetOptions(this TweenerCore<DOVector4, DOVector4, VectorOptions> t, AxisConstraint axisConstraint, bool snapping = false)
{
if (t == null || !t.active) return t;
@ -672,11 +658,7 @@ namespace DG.Tweening
/// <summary>Options for Quaternion tweens</summary>
/// <param name="useShortest360Route">If TRUE (default) the rotation will take the shortest route, and will not rotate more than 360°.
/// If FALSE the rotation will be fully accounted. Is always FALSE if the tween is set as relative</param>
#if WP81
public static Tweener SetOptions(this TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions> t, bool useShortest360Route = true)
#else
public static Tweener SetOptions(this TweenerCore<Quaternion, Vector3, QuaternionOptions> t, bool useShortest360Route = true)
#endif
public static Tweener SetOptions(this TweenerCore<DOQuaternion, DOVector3, QuaternionOptions> t, bool useShortest360Route = true)
{
if (t == null || !t.active) return t;
@ -686,11 +668,7 @@ namespace DG.Tweening
/// <summary>Options for Color tweens</summary>
/// <param name="alphaOnly">If TRUE only the alpha value of the color will be tweened</param>
#if WP81
public static Tweener SetOptions(this TweenerCore<ColorSurrogate, ColorSurrogate, ColorOptions> t, bool alphaOnly)
#else
public static Tweener SetOptions(this TweenerCore<Color, Color, ColorOptions> t, bool alphaOnly)
#endif
public static Tweener SetOptions(this TweenerCore<DOColor, DOColor, ColorOptions> t, bool alphaOnly)
{
if (t == null || !t.active) return t;

56
_DOTween.Assembly/DOTween/Tweener.cs
View File

@ -4,10 +4,13 @@
// License Copyright (c) Daniele Giardini.
// This work is subject to the terms at http://dotween.demigiant.com/license.php
#if WP81
using DG.Tweening.Core.Surrogates;
#if COMPATIBLE
using DOVector3 = DG.Tweening.Core.Surrogates.Vector3Wrapper;
using DOQuaternion = DG.Tweening.Core.Surrogates.QuaternionWrapper;
#else
using DOVector3 = UnityEngine.Vector3;
using DOQuaternion = UnityEngine.Quaternion;
#endif
using System;
using DG.Tweening.Core;
using DG.Tweening.Core.Enums;
using DG.Tweening.Plugins.Core;
@ -70,53 +73,12 @@ namespace DG.Tweening
{
if (plugin != null) t.tweenPlugin = plugin;
else {
#if !WP81
if (t.tweenPlugin == null) t.tweenPlugin = PluginsManager.GetDefaultPlugin<T1, T2, TPlugOptions>();
if (t.tweenPlugin == null) {
// No suitable plugin found. Kill
Debugger.LogError("No suitable plugin found for this type");
return false;
}
#else
if (t.tweenPlugin == null) t.tweenPlugin = PluginsManager.GetDefaultPlugin<T1, T2, TPlugOptions>();
if (t.tweenPlugin == null) {
// No suitable plugin found. Kill
Debugger.LogError(string.Format("No suitable plugin found for this type (<{0}, {1}, {2}>)", typeof(T1), typeof(T2), typeof(TPlugOptions)));
return false;
}
// WP8.1 fix tries
// if (t.tweenPlugin == null) {
// Debug.Log("Assigning plugin to ABSTweenPlugin<T1, T2, TPlugOptions> var");
// ABSTweenPlugin<T1, T2, TPlugOptions> plug = PluginsManager.GetDefaultPlugin<T1, T2, TPlugOptions>();
// if (plug != null) {
// Debug.Log(">> Plugin found");
// t.tweenPlugin = plug;
// Debug.Log(">> Plugin assigned > " + t.tweenPlugin + " (t.tweenPlugin is null: " + (t.tweenPlugin == null) + ")");
// if (t.tweenPlugin == null) Debug.Log(">> Plugin assignment failed");
// } else Debug.Log(">> Plugin NOT found");
// }
// if (t.tweenPlugin == null) {
// Debug.Log("Assigning plugin to ITweenPlugin var");
// ITweenPlugin iplug = PluginsManager.GetDefaultPlugin<T1, T2, TPlugOptions>();
// if (iplug != null) {
// Debug.Log(">> IPlugin found");
// try {
// System.Object pObj = (object)iplug;
// t.tweenPlugin = (ABSTweenPlugin<T1, T2, TPlugOptions>)pObj;
// } catch (Exception e) {
// Debug.Log(">> Error while assigning IPlugin > " + e.Message);
// }
// Debug.Log(">> IPlugin assigned > " + t.tweenPlugin + " (t.tweenPlugin is null: " + (t.tweenPlugin == null) + ")");
// if (t.tweenPlugin == null) Debug.Log(">> IPlugin assignment failed");
// } else Debug.Log(">> IPlugin NOT found");
// }
// if (t.tweenPlugin == null) {
// // No suitable plugin found. Kill
// Debugger.LogError("No suitable plugin found for this type");
// return false;
// }
// WP8.1 fix tries END
#endif
}
t.getter = getter;
@ -286,11 +248,7 @@ namespace DG.Tweening
try {
switch (t.specialStartupMode) {
case SpecialStartupMode.SetLookAt:
#if WP81
if (!SpecialPluginsUtils.SetLookAt(t as TweenerCore<QuaternionSurrogate, Vector3Surrogate, QuaternionOptions>)) return false;
#else
if (!SpecialPluginsUtils.SetLookAt(t as TweenerCore<Quaternion, Vector3, QuaternionOptions>)) return false;
#endif
if (!SpecialPluginsUtils.SetLookAt(t as TweenerCore<DOQuaternion, DOVector3, QuaternionOptions>)) return false;
break;
case SpecialStartupMode.SetPunch:
if (!SpecialPluginsUtils.SetPunch(t as TweenerCore<Vector3, Vector3[], Vector3ArrayOptions>)) return false;

4
_DOTween.Assembly/DOTween43/DOTween43.csproj
View File

@ -34,9 +34,9 @@
<DocumentationFile>..\bin\DOTween43.xml</DocumentationFile>
<NoWarn>1573</NoWarn>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'WP81|AnyCPU'">
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'CompatibilityMode|AnyCPU' ">
<OutputPath>..\bin\</OutputPath>
<DefineConstants>TRACE;WP81</DefineConstants>
<DefineConstants>TRACE;COMPATIBLE</DefineConstants>
<DocumentationFile>..\bin\DOTween43.xml</DocumentationFile>
<Optimize>true</Optimize>
<NoWarn>1573</NoWarn>

25
_DOTween.Assembly/DOTween43/ShortcutExtensions.cs
View File

@ -4,12 +4,7 @@
// License Copyright (c) Daniele Giardini.
// This work is subject to the terms at http://dotween.demigiant.com/license.php
#if WP81
using DG.Tweening.Core.Surrogates;
#endif
using DG.Tweening.Core;
using DG.Tweening.Core.Enums;
using DG.Tweening.Plugins.Options;
using UnityEngine;
namespace DG.Tweening
@ -49,8 +44,8 @@ namespace DG.Tweening
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOMove(this Rigidbody2D target, Vector2 endValue, float duration, bool snapping = false)
{
#if WP81
return DOTween.To(() => target.position, x=> target.MovePosition(x), endValue, duration)
#if COMPATIBLE
return DOTween.To(() => target.position, x=> target.MovePosition(x.value), endValue, duration)
#else
return DOTween.To(() => target.position, target.MovePosition, endValue, duration)
#endif
@ -63,8 +58,8 @@ namespace DG.Tweening
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOMoveX(this Rigidbody2D target, float endValue, float duration, bool snapping = false)
{
#if WP81
return DOTween.To(() => target.position, x => target.MovePosition(x), new Vector2(endValue, 0), duration)
#if COMPATIBLE
return DOTween.To(() => target.position, x => target.MovePosition(x.value), new Vector2(endValue, 0), duration)
#else
return DOTween.To(() => target.position, target.MovePosition, new Vector2(endValue, 0), duration)
#endif
@ -77,8 +72,8 @@ namespace DG.Tweening
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOMoveY(this Rigidbody2D target, float endValue, float duration, bool snapping = false)
{
#if WP81
return DOTween.To(() => target.position, x => target.MovePosition(x), new Vector2(0, endValue), duration)
#if COMPATIBLE
return DOTween.To(() => target.position, x => target.MovePosition(x.value), new Vector2(0, endValue), duration)
#else
return DOTween.To(() => target.position, target.MovePosition, new Vector2(0, endValue), duration)
#endif
@ -108,13 +103,13 @@ namespace DG.Tweening
public static Tweener DOBlendableColor(this SpriteRenderer target, Color endValue, float duration)
{
endValue = endValue - target.color;
#if WP81
ColorSurrogate to = new ColorSurrogate(0, 0, 0, 0);
#else
Color to = new Color(0, 0, 0, 0);
#endif
return DOTween.To(() => to, x => {
#if COMPATIBLE
Color diff = x.value - to;
#else
Color diff = x - to;
#endif
to = x;
target.color += diff;
}, endValue, duration)

4
_DOTween.Assembly/DOTween46/DOTween46.csproj
View File

@ -34,9 +34,9 @@
<DocumentationFile>..\bin\DOTween46.xml</DocumentationFile>
<NoWarn>1573</NoWarn>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'WP81|AnyCPU'">
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'CompatibilityMode|AnyCPU' ">
<OutputPath>..\bin\</OutputPath>
<DefineConstants>TRACE;WP81</DefineConstants>
<DefineConstants>TRACE;COMPATIBLE</DefineConstants>
<DocumentationFile>..\bin\DOTween46.xml</DocumentationFile>
<Optimize>true</Optimize>
<NoWarn>1573</NoWarn>

43
_DOTween.Assembly/DOTween46/ShortcutExtensions.cs
View File

@ -4,11 +4,7 @@
// License Copyright (c) Daniele Giardini.
// This work is subject to the terms at http://dotween.demigiant.com/license.php
#if WP81
using DG.Tweening.Core.Surrogates;
#endif
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
using UnityEngine.UI;
@ -97,8 +93,13 @@ namespace DG.Tweening
public static Tweener DOFlexibleSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false)
{
return DOTween.To(() => new Vector2(target.flexibleWidth, target.flexibleHeight), x => {
#if COMPATIBLE
target.flexibleWidth = x.value.x;
target.flexibleHeight = x.value.y;
#else
target.flexibleWidth = x.x;
target.flexibleHeight = x.y;
#endif
}, endValue, duration)
.SetOptions(snapping).SetTarget(target);
}
@ -110,8 +111,13 @@ namespace DG.Tweening
public static Tweener DOMinSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false)
{
return DOTween.To(() => new Vector2(target.minWidth, target.minHeight), x => {
#if COMPATIBLE
target.minWidth = x.value.x;
target.minHeight = x.value.y;
#else
target.minWidth = x.x;
target.minHeight = x.y;
#endif
}, endValue, duration)
.SetOptions(snapping).SetTarget(target);
}
@ -123,8 +129,13 @@ namespace DG.Tweening
public static Tweener DOPreferredSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false)
{
return DOTween.To(() => new Vector2(target.preferredWidth, target.preferredHeight), x => {
#if COMPATIBLE
target.preferredWidth = x.value.x;
target.preferredHeight = x.value.y;
#else
target.preferredWidth = x.x;
target.preferredHeight = x.y;
#endif
}, endValue, duration)
.SetOptions(snapping).SetTarget(target);
}
@ -260,13 +271,13 @@ namespace DG.Tweening
public static Tweener DOBlendableColor(this Graphic target, Color endValue, float duration)
{
endValue = endValue - target.color;
#if WP81
ColorSurrogate to = new ColorSurrogate(0, 0, 0, 0);
#else
Color to = new Color(0, 0, 0, 0);
#endif
return DOTween.To(() => to, x => {
#if COMPATIBLE
Color diff = x.value - to;
#else
Color diff = x - to;
#endif
to = x;
target.color += diff;
}, endValue, duration)
@ -285,13 +296,13 @@ namespace DG.Tweening
public static Tweener DOBlendableColor(this Image target, Color endValue, float duration)
{
endValue = endValue - target.color;
#if WP81
ColorSurrogate to = new ColorSurrogate(0, 0, 0, 0);
#else
Color to = new Color(0, 0, 0, 0);
#endif
return DOTween.To(() => to, x => {
#if COMPATIBLE
Color diff = x.value - to;
#else
Color diff = x - to;
#endif
to = x;
target.color += diff;
}, endValue, duration)
@ -310,13 +321,13 @@ namespace DG.Tweening
public static Tweener DOBlendableColor(this Text target, Color endValue, float duration)
{
endValue = endValue - target.color;
#if WP81
ColorSurrogate to = new ColorSurrogate(0, 0, 0, 0);
#else
Color to = new Color(0, 0, 0, 0);
#endif
return DOTween.To(() => to, x => {
#if COMPATIBLE
Color diff = x.value - to;
#else
Color diff = x - to;
#endif
to = x;
target.color += diff;
}, endValue, duration)

2
_DOTween.Assembly/DOTween50/DOTween50.csproj
View File

@ -34,7 +34,7 @@
<DocumentationFile>..\bin\DOTween50.xml</DocumentationFile>
<NoWarn>1573</NoWarn>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'WP81|AnyCPU'">
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'CompatibilityMode|AnyCPU' ">
<OutputPath>..\bin\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<DocumentationFile>..\bin\DOTween50.xml</DocumentationFile>

4
_DOTween.Assembly/DOTweenEditor/DOTweenEditor.csproj
View File

@ -34,9 +34,9 @@
<DocumentationFile>..\bin\Editor\DOTweenEditor.XML</DocumentationFile>
<NoWarn>1591</NoWarn>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'WP81|AnyCPU'">
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'CompatibilityMode|AnyCPU' ">
<OutputPath>..\bin\Editor\</OutputPath>
<DefineConstants>TRACE;WP81</DefineConstants>
<DefineConstants>TRACE;COMPATIBLE</DefineConstants>
<DocumentationFile>..\bin\Editor\DOTweenEditor.XML</DocumentationFile>
<Optimize>true</Optimize>
<NoWarn>1591</NoWarn>

4
_DOTween.Assembly/DOTweenEditor/DOTweenUtilityWindow.cs
View File

@ -80,8 +80,8 @@ namespace DG.DOTweenEditor
void OnEnable()
{
#if WP81
_innerTitle = "DOTween v" + DOTween.Version + (DOTween.isDebugBuild ? " [Debug WP8.1 build]" : " [Release WP8.1 build]");
#if COMPATIBLE
_innerTitle = "DOTween v" + DOTween.Version + (DOTween.isDebugBuild ? " [Debug Compatibility build]" : " [Release Compatibility build]");
#else
_innerTitle = "DOTween v" + DOTween.Version + (DOTween.isDebugBuild ? " [Debug build]" : " [Release build]");
#endif

30
_DOTween.Assembly/bin/DOTween.XML
View File

@ -532,39 +532,39 @@
<summary>Options for float tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector2,UnityEngine.Vector2,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<summary>Options for Vector2 tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector2,UnityEngine.Vector2,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Core.Surrogates.Vector2Wrapper,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<summary>Options for Vector2 tweens</summary>
<param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector3,UnityEngine.Vector3,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<summary>Options for Vector3 tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector3,UnityEngine.Vector3,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<summary>Options for Vector3 tweens</summary>
<param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector4,UnityEngine.Vector4,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Plugins.Options.VectorOptions},System.Boolean)">
<summary>Options for Vector4 tweens</summary>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Vector4,UnityEngine.Vector4,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Core.Surrogates.Vector4Wrapper,DG.Tweening.Plugins.Options.VectorOptions},DG.Tweening.AxisConstraint,System.Boolean)">
<summary>Options for Vector4 tweens</summary>
<param name="axisConstraint">Selecting an axis will tween the vector only on that axis, leaving the others untouched</param>
<param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Quaternion,UnityEngine.Vector3,DG.Tweening.Plugins.Options.QuaternionOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.QuaternionWrapper,DG.Tweening.Core.Surrogates.Vector3Wrapper,DG.Tweening.Plugins.Options.QuaternionOptions},System.Boolean)">
<summary>Options for Quaternion tweens</summary>
<param name="useShortest360Route">If TRUE (default) the rotation will take the shortest route, and will not rotate more than 360°.
If FALSE the rotation will be fully accounted. Is always FALSE if the tween is set as relative</param>
</member>
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{UnityEngine.Color,UnityEngine.Color,DG.Tweening.Plugins.Options.ColorOptions},System.Boolean)">
<member name="M:DG.Tweening.TweenSettingsExtensions.SetOptions(DG.Tweening.Core.TweenerCore{DG.Tweening.Core.Surrogates.ColorWrapper,DG.Tweening.Core.Surrogates.ColorWrapper,DG.Tweening.Plugins.Options.ColorOptions},System.Boolean)">
<summary>Options for Color tweens</summary>
<param name="alphaOnly">If TRUE only the alpha value of the color will be tweened</param>
</member>
@ -1507,7 +1507,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Vector2},DG.Tweening.Core.DOSetter{UnityEngine.Vector2},UnityEngine.Vector2,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector2Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector2Wrapper},UnityEngine.Vector2,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1515,7 +1515,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Vector3},DG.Tweening.Core.DOSetter{UnityEngine.Vector3},UnityEngine.Vector3,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},UnityEngine.Vector3,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1523,7 +1523,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Vector4},DG.Tweening.Core.DOSetter{UnityEngine.Vector4},UnityEngine.Vector4,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector4Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector4Wrapper},UnityEngine.Vector4,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1531,7 +1531,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Quaternion},DG.Tweening.Core.DOSetter{UnityEngine.Quaternion},UnityEngine.Vector3,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.QuaternionWrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.QuaternionWrapper},UnityEngine.Vector3,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1539,7 +1539,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{UnityEngine.Color},DG.Tweening.Core.DOSetter{UnityEngine.Color},UnityEngine.Color,System.Single)">
<member name="M:DG.Tweening.DOTween.To(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.ColorWrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.ColorWrapper},UnityEngine.Color,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.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1574,7 +1574,7 @@
<para>Example usage with lambda:</para><code>x=> myProperty = x</code></param>
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
</member>
<member name="M:DG.Tweening.DOTween.ToAxis(DG.Tweening.Core.DOGetter{UnityEngine.Vector3},DG.Tweening.Core.DOSetter{UnityEngine.Vector3},System.Single,System.Single,DG.Tweening.AxisConstraint)">
<member name="M:DG.Tweening.DOTween.ToAxis(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.Vector3Wrapper},System.Single,System.Single,DG.Tweening.AxisConstraint)">
<summary>Tweens only one axis of a Vector3 to the given value using default plugins.</summary>
<param name="getter">A getter for the field or property to tween.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>
@ -1583,7 +1583,7 @@
<param name="endValue">The end value to reach</param><param name="duration">The tween's duration</param>
<param name="axisConstraint">The axis to tween</param>
</member>
<member name="M:DG.Tweening.DOTween.ToAlpha(DG.Tweening.Core.DOGetter{UnityEngine.Color},DG.Tweening.Core.DOSetter{UnityEngine.Color},System.Single,System.Single)">
<member name="M:DG.Tweening.DOTween.ToAlpha(DG.Tweening.Core.DOGetter{DG.Tweening.Core.Surrogates.ColorWrapper},DG.Tweening.Core.DOSetter{DG.Tweening.Core.Surrogates.ColorWrapper},System.Single,System.Single)">
<summary>Tweens only the alpha of a Color to the given value using default plugins</summary>
<param name="getter">A getter for the field or property to tween.
<para>Example usage with lambda:</para><code>()=> myProperty</code></param>

BIN
_DOTween.Assembly/bin/DOTween.dll
View File

Binary file not shown.

BIN
_DOTween.Assembly/bin/DOTween.dll.mdb
View File

Binary file not shown.

BIN
_DOTween.Assembly/bin/DOTween43.dll
View File

Binary file not shown.

BIN
_DOTween.Assembly/bin/DOTween43.dll.mdb
View File

Binary file not shown.

BIN
_DOTween.Assembly/bin/DOTween46.dll
View File

Binary file not shown.

BIN
_DOTween.Assembly/bin/DOTween46.dll.mdb
View File

Binary file not shown.

BIN
_DOTween.Assembly/bin/DOTween50.dll
View File

Binary file not shown.

BIN
_DOTween.Assembly/bin/DOTween50.dll.mdb
View File

Binary file not shown.

BIN
_DOTween.Assembly/bin/Editor/DOTweenEditor.dll
View File

Binary file not shown.

BIN
_DOTween.Assembly/bin/Editor/DOTweenEditor.dll.mdb
View File

Binary file not shown.