From a5313a94e00411555dc4909c3be5befd59483a83 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B9=80=EB=8F=84=ED=99=98?= Date: Sun, 10 May 2026 01:23:07 +0900 Subject: [PATCH] Dotween Added --- Assets/Plugins.meta | 8 + Assets/Plugins/Demigiant.meta | 8 + Assets/Plugins/Demigiant/DOTween.meta | 21 + Assets/Plugins/Demigiant/DOTween/DOTween.XML | 3107 +++++++++++++++++ .../Demigiant/DOTween/DOTween.XML.meta | 11 + Assets/Plugins/Demigiant/DOTween/DOTween.dll | Bin 0 -> 177664 bytes .../Demigiant/DOTween/DOTween.dll.meta | 29 + Assets/Plugins/Demigiant/DOTween/Editor.meta | 5 + .../DOTween/Editor/DOTweenEditor.XML | 165 + .../DOTween/Editor/DOTweenEditor.XML.meta | 11 + .../DOTween/Editor/DOTweenEditor.dll | Bin 0 -> 66560 bytes .../DOTween/Editor/DOTweenEditor.dll.meta | 29 + .../DOTween/Editor/DOTweenUpgradeManager.XML | 14 + .../Editor/DOTweenUpgradeManager.XML.meta | 11 + .../DOTween/Editor/DOTweenUpgradeManager.dll | Bin 0 -> 11264 bytes .../Editor/DOTweenUpgradeManager.dll.meta | 29 + .../Demigiant/DOTween/Editor/Imgs.meta | 5 + .../DOTween/Editor/Imgs/DOTweenIcon.png | Bin 0 -> 1565 bytes .../DOTween/Editor/Imgs/DOTweenIcon.png.meta | 54 + .../DOTween/Editor/Imgs/DOTweenMiniIcon.png | Bin 0 -> 319 bytes .../Editor/Imgs/DOTweenMiniIcon.png.meta | 75 + .../Demigiant/DOTween/Editor/Imgs/Footer.png | Bin 0 -> 4409 bytes .../DOTween/Editor/Imgs/Footer.png.meta | 54 + .../DOTween/Editor/Imgs/Footer_dark.png | Bin 0 -> 4429 bytes .../DOTween/Editor/Imgs/Footer_dark.png.meta | 54 + .../Demigiant/DOTween/Editor/Imgs/Header.jpg | Bin 0 -> 22787 bytes .../DOTween/Editor/Imgs/Header.jpg.meta | 54 + Assets/Plugins/Demigiant/DOTween/Modules.meta | 5 + .../DOTween/Modules/DOTweenModuleAudio.cs | 198 ++ .../Modules/DOTweenModuleAudio.cs.meta | 15 + .../Modules/DOTweenModuleEPOOutline.cs | 146 + .../Modules/DOTweenModuleEPOOutline.cs.meta | 19 + .../DOTween/Modules/DOTweenModulePhysics.cs | 216 ++ .../Modules/DOTweenModulePhysics.cs.meta | 15 + .../DOTween/Modules/DOTweenModulePhysics2D.cs | 193 + .../Modules/DOTweenModulePhysics2D.cs.meta | 15 + .../DOTween/Modules/DOTweenModuleSprite.cs | 93 + .../Modules/DOTweenModuleSprite.cs.meta | 15 + .../DOTween/Modules/DOTweenModuleUI.cs | 662 ++++ .../DOTween/Modules/DOTweenModuleUI.cs.meta | 15 + .../DOTween/Modules/DOTweenModuleUIToolkit.cs | 161 + .../Modules/DOTweenModuleUIToolkit.cs.meta | 18 + .../Modules/DOTweenModuleUnityVersion.cs | 389 +++ .../Modules/DOTweenModuleUnityVersion.cs.meta | 15 + .../DOTween/Modules/DOTweenModuleUtils.cs | 167 + .../Modules/DOTweenModuleUtils.cs.meta | 15 + Assets/Plugins/Demigiant/DOTween/readme.txt | 29 + .../Plugins/Demigiant/DOTween/readme.txt.meta | 11 + 48 files changed, 6156 insertions(+) create mode 100644 Assets/Plugins.meta create mode 100644 Assets/Plugins/Demigiant.meta create mode 100644 Assets/Plugins/Demigiant/DOTween.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/DOTween.XML create mode 100644 Assets/Plugins/Demigiant/DOTween/DOTween.XML.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/DOTween.dll create mode 100644 Assets/Plugins/Demigiant/DOTween/DOTween.dll.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.XML create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.XML.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.dll create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.dll.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenMiniIcon.png create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenMiniIcon.png.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/readme.txt create mode 100644 Assets/Plugins/Demigiant/DOTween/readme.txt.meta diff --git a/Assets/Plugins.meta b/Assets/Plugins.meta new file mode 100644 index 0000000..830007c --- /dev/null +++ b/Assets/Plugins.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: fb933ea5343323245996b9045f3e288a +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Plugins/Demigiant.meta b/Assets/Plugins/Demigiant.meta new file mode 100644 index 0000000..1979939 --- /dev/null +++ b/Assets/Plugins/Demigiant.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 2bdbc082abaa9574b966e21c22f42551 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Plugins/Demigiant/DOTween.meta b/Assets/Plugins/Demigiant/DOTween.meta new file mode 100644 index 0000000..cbebc39 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween.meta @@ -0,0 +1,21 @@ +fileFormatVersion: 2 +guid: a50bd9a009c8dfc4ebd88cc8101225a7 +labels: +- Tween +- Tweening +- Animation +- HOTween +- Paths +- iTween +- DFTween +- LeanTween +- Ease +- Easing +- Shake +- Punch +- 2DToolkit +- TextMeshPro +- Text +folderAsset: yes +DefaultImporter: + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/DOTween.XML b/Assets/Plugins/Demigiant/DOTween/DOTween.XML new file mode 100644 index 0000000..f56085a --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/DOTween.XML @@ -0,0 +1,3107 @@ + + + + DOTween + + + + + Types of autoPlay behaviours + + + + No tween is automatically played + + + Only Sequences are automatically played + + + Only Tweeners are automatically played + + + All tweens are automatically played + + + + What axis to constrain in case of Vector tweens + + + + Called the first time the tween is set in a playing state, after any eventual delay + + + + Used in place of System.Func, which is not available in mscorlib. + + + + + Used in place of System.Action. + + + + + Public so it can be used by lose scripts related to DOTween (like DOTweenAnimation) + + + + + Used to separate DOTween class from the MonoBehaviour instance (in order to use static constructors on DOTween). + Contains all instance-based methods + + + + Used internally inside Unity Editor, as a trick to update DOTween's inspector at every frame + + + + Directly sets the current max capacity of Tweeners and Sequences + (meaning how many Tweeners and Sequences can be running at the same time), + so that DOTween doesn't need to automatically increase them in case the max is reached + (which might lead to hiccups when that happens). + Sequences capacity must be less or equal to Tweeners capacity + (if you pass a low Tweener capacity it will be automatically increased to match the Sequence's). + Beware: use this method only when there are no tweens running. + + Max Tweeners capacity. + Default: 200 + Max Sequences capacity. + Default: 50 + + + + This class contains a C# port of the easing equations created by Robert Penner (http://robertpenner.com/easing). + + + + + Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in: accelerating from zero velocity. + + + Current time (in frames or seconds). + + + Expected easing duration (in frames or seconds). + + Unused: here to keep same delegate for all ease types. + Unused: here to keep same delegate for all ease types. + + The eased value. + + + + + Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out: decelerating from zero velocity. + + + Current time (in frames or seconds). + + + Expected easing duration (in frames or seconds). + + Unused: here to keep same delegate for all ease types. + Unused: here to keep same delegate for all ease types. + + The eased value. + + + + + Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in/out: acceleration until halfway, then deceleration. + + + Current time (in frames or seconds). + + + Expected easing duration (in frames or seconds). + + Unused: here to keep same delegate for all ease types. + Unused: here to keep same delegate for all ease types. + + The eased value. + + + + + Returns a value between 0 and 1 (inclusive) based on the elapsed time and ease selected. + Use this method if you don't care about , otherwise use + + + + + USE THIS FOR CUSTOM PLUGINS when you want to be able to use . + Returns a value that is from 0 to 1 if is not incremental, otherwise from 0 to (1 * completed loops) + + + + + Returns a value between 0 and 1 (inclusive) based on the elapsed time and ease selected + + + + + Used to interpret AnimationCurves as eases. + Public so it can be used by external ease factories + + + + + Behaviour in case a tween nested inside a Sequence fails and is captured by safe mode + + + + If the Sequence contains other elements, kill the failed tween but preserve the rest + + + Kill the whole Sequence + + + + Log types thrown by errors captured and prevented by safe mode + + + + No logs. NOT RECOMMENDED + + + Throw a normal log + + + Throw a warning log (default) + + + Throw an error log + + + + Additional notices passed to plugins when updating. + Public so it can be used by custom plugins. Internally, only PathPlugin uses it + + + + + None + + + + + Lets the plugin know that we restarted or rewinded + + + + + OnRewind callback behaviour (can only be set via DOTween's Utility Panel) + + + + + When calling Rewind or PlayBackwards/SmoothRewind, OnRewind callbacks will be fired only if the tween isn't already rewinded + + + + + When calling Rewind, OnRewind callbacks will always be fired, even if the tween is already rewinded. + When calling PlayBackwards/SmoothRewind instead, OnRewind callbacks will be fired only if the tween isn't already rewinded + + + + + When calling Rewind or PlayBackwards/SmoothRewind, OnRewind callbacks will always be fired, even if the tween is already rewinded + + + + + Public only so custom shortcuts can access some of these methods + + + + + INTERNAL: used by DO shortcuts and Modules to set special startup mode + + + + + INTERNAL: used by DO shortcuts and Modules to set the tween as blendable + + + + + INTERNAL: used by DO shortcuts and Modules to prevent a tween from using a From setup even if passed + + + + + Used to dispatch commands that need to be captured externally, usually by Modules + + + + + Various utils + + + + + Returns a Vector3 with z = 0 + + + + + Returns the 2D angle between two vectors + + + + + Returns a point on a circle with the given center and radius, + using Unity's circle coordinates (0° points up and increases clockwise) + + + + + Uses approximate equality on each axis instead of Unity's Vector3 equality, + because the latter fails (in some cases) when assigning a Vector3 to a transform.position and then checking it. + + + + + Looks for the type within all possible project assembly names + + + + NO-GC METHOD: changes the start value of a tween and rewinds it (without pausing it). + Has no effect with tweens that are inside Sequences + The new start value + If bigger than 0 applies it as the new tween duration + + + NO-GC METHOD: changes the end value of a tween and rewinds it (without pausing it). + Has no effect with tweens that are inside Sequences + The new end value + If TRUE the start value will become the current target's value, otherwise it will stay the same + + + NO-GC METHOD: changes the end value of a tween and rewinds it (without pausing it). + Has no effect with tweens that are inside Sequences + The new end value + If bigger than 0 applies it as the new tween duration + If TRUE the start value will become the current target's value, otherwise it will stay the same + + + NO-GC METHOD: changes the start and end value of a tween and rewinds it (without pausing it). + Has no effect with tweens that are inside Sequences + The new start value + The new end value + If bigger than 0 applies it as the new tween duration + + + + Struct that stores two colors (used for LineRenderer tweens) + + + + + Used for tween callbacks + + + + + Used for tween callbacks + + + + + Used for custom and animationCurve-based ease functions. Must return a value between 0 and 1. + + + + + Straight Quaternion plugin. Instead of using Vector3 values accepts Quaternion values directly. + Beware: doesn't work with LoopType.Incremental (neither directly nor if inside a LoopType.Incremental Sequence). + To use it, call DOTween.To with the plugin parameter overload, passing it PureQuaternionPlugin.Plug() as first parameter + (do not use any of the other public PureQuaternionPlugin methods): + DOTween.To(PureQuaternionPlugin.Plug(), ()=> myQuaternionProperty, x=> myQuaternionProperty = x, myQuaternionEndValue, duration); + + + + + Plug this plugin inside a DOTween.To call. + Example: + DOTween.To(PureQuaternionPlugin.Plug(), ()=> myQuaternionProperty, x=> myQuaternionProperty = x, myQuaternionEndValue, duration); + + + + INTERNAL: do not use + + + INTERNAL: do not use + + + INTERNAL: do not use + + + INTERNAL: do not use + + + INTERNAL: do not use + + + INTERNAL: do not use + + + INTERNAL: do not use + + + INTERNAL: do not use + + + + Extra non-tweening-related curve methods + + + + + Cubic bezier curve methods + + + + + Calculates a point along the given Cubic Bezier segment-curve. + + Segment start point + Start point's control point/handle + Segment end point + End point's control point/handle + 0-1 percentage along which to retrieve point + + + + Returns an array containing a series of points along the given Cubic Bezier segment-curve. + + Start point + Start point's control point/handle + End point + End point's control point/handle + Cloud resolution (min: 2) + + + + Calculates a series of points along the given Cubic Bezier segment-curve and adds them to the given list. + + Start point + Start point's control point/handle + End point + End point's control point/handle + Cloud resolution (min: 2) + + + + Main DOTween class. Contains static methods to create and control tweens in a generic way + + + + DOTween's version + + + If TRUE (default) makes tweens slightly slower but safer, automatically taking care of a series of things + (like targets becoming null while a tween is playing). + Default: TRUE + + + Log type when safe mode reports capturing an error and preventing it + + + Behaviour in case a tween nested inside a Sequence fails (and is caught by safe mode). + Default: NestedTweenFailureBehaviour.TryToPreserveSequence + + + If TRUE you will get a DOTween report when exiting play mode (only in the Editor). + Useful to know how many max Tweeners and Sequences you reached and optimize your final project accordingly. + Beware, this will slightly slow down your tweens while inside Unity Editor. + Default: FALSE + + + Global DOTween global timeScale (default: 1). + The final timeScale of a non-timeScaleIndependent tween is: + Unity's Time.timeScale * DOTween.timeScale * tween.timeScale + while the final timeScale of a timeScaleIndependent tween is: + DOTween.unscaledTimeScale * DOTween.timeScale * tween.timeScale + + + DOTween timeScale applied only to timeScaleIndependent tweens (default: 1). + The final timeScale of a timeScaleIndependent tween is: + DOTween.unscaledTimeScale * DOTween.timeScale * tween.timeScale + + + If TRUE, DOTween will use Time.smoothDeltaTime instead of Time.deltaTime for UpdateType.Normal and UpdateType.Late tweens + (unless they're set as timeScaleIndependent, in which case a value between the last timestep + and will be used instead). + Setting this to TRUE will lead to smoother animations. + Default: FALSE + + + If is TRUE, this indicates the max timeStep that an independent update call can last. + Setting this to TRUE will lead to smoother animations. + Default: FALSE + + + DOTween's log behaviour. + Default: LogBehaviour.ErrorsOnly + + + Used to intercept DOTween's logs. If this method isn't NULL, DOTween will call it before writing a log via Unity's own Debug log methods. + Return TRUE if you want DOTween to proceed with the log, FALSE otherwise. + This method must return a bool and accept two parameters: + - LogType: the type of Unity log that DOTween is trying to log + - object: the log message that DOTween wants to log + + + If TRUE draws path gizmos in Unity Editor (if the gizmos button is active). + Deactivate this if you want to avoid gizmos overhead while in Unity Editor + + + Gets/sets the max Tweeners capacity (automatically increased by DOTween when necessary). + You can also set both Tweeners and Sequences capacity via the static method + + + Gets/sets the max Sequences capacity (automatically increased by DOTween when necessary). + You can also set both Tweeners and Sequences capacity via the static method + + + If TRUE activates various debug options + + + Stores the target id so it can be used to give more info in case of safeMode error capturing. + Only active if both debugMode and useSafeMode are TRUE + + + Default updateType for new tweens. + Default: UpdateType.Normal + + + Sets whether Unity's timeScale should be taken into account by default or not. + Default: false + + + Default autoPlay behaviour for new tweens. + Default: AutoPlay.All + + + Default autoKillOnComplete behaviour for new tweens. + Default: TRUE + + + Default loopType applied to all new tweens. + Default: LoopType.Restart + + + If TRUE all newly created tweens are set as recyclable, otherwise not. + Default: FALSE + + + Default ease applied to all new Tweeners (not to Sequences which always have Ease.Linear as default). + Default: Ease.InOutQuad + + + Default overshoot/amplitude used for eases + Default: 1.70158f + + + Default period used for eases + Default: 0 + + + Used internally. Assigned/removed by DOTweenComponent.Create/DestroyInstance + + + + Must be called once, before the first ever DOTween call/reference, + otherwise it will be called automatically and will use default options. + Calling it a second time won't have any effect. + You can chain SetCapacity to this method, to directly set the max starting size of Tweeners and Sequences: + DOTween.Init(false, false, LogBehaviour.Default).SetCapacity(100, 20); + + If TRUE all new tweens will be set for recycling, meaning that when killed, + instead of being destroyed, they will be put in a pool and reused instead of creating new tweens. This option allows you to avoid + GC allocations by reusing tweens, but you will have to take care of tween references, since they might result active + even if they were killed (since they might have been respawned and are now being used for other tweens). + If you want to automatically set your tween references to NULL when a tween is killed + you can use the OnKill callback like this: + .OnKill(()=> myTweenReference = null) + You can change this setting at any time by changing the static property, + or you can set the recycling behaviour for each tween separately, using: + SetRecyclable(bool recyclable) + Default: FALSE + If TRUE makes tweens slightly slower but safer, automatically taking care of a series of things + (like targets becoming null while a tween is playing). + You can change this setting at any time by changing the static property. + Default: FALSE + Type of logging to use. + You can change this setting at any time by changing the static property. + Default: ErrorsOnly + + + + Directly sets the current max capacity of Tweeners and Sequences + (meaning how many Tweeners and Sequences can be running at the same time), + so that DOTween doesn't need to automatically increase them in case the max is reached + (which might lead to hiccups when that happens). + Sequences capacity must be less or equal to Tweeners capacity + (if you pass a low Tweener capacity it will be automatically increased to match the Sequence's). + Beware: use this method only when there are no tweens running. + + Max Tweeners capacity. + Default: 200 + Max Sequences capacity. + Default: 50 + + + + Kills all tweens, clears all cached tween pools and plugins and resets the max Tweeners/Sequences capacities to the default values. + + If TRUE also destroys DOTween's gameObject and resets its initializiation, default settings and everything else + (so that next time you use it it will need to be re-initialized) + + + + Clears all cached tween pools. + + + + + Checks all active tweens to find and remove eventually invalid ones (usually because their targets became NULL) + and returns the total number of invalid tweens found and removed. + IMPORTANT: this will cause an error on UWP platform, so don't use it there + BEWARE: this is a slightly expensive operation so use it with care + + + + + Updates all tweens that are set to . + + Manual deltaTime + Unscaled delta time (used with tweens set as timeScaleIndependent) + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a property or field to the given value using a custom plugin + The plugin to use. Each custom plugin implements a static Get() method + you'll need to call to assign the correct plugin in the correct way, like this: + CustomPlugin.Get() + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens only one axis of a Vector3 to the given value using default plugins. + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + The axis to tween + + + Tweens only the alpha of a Color to the given value using default plugins + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end value to reachThe tween's duration + + + Tweens a virtual property from the given start to the given end value + and implements a setter that allows to use that value with an external method or a lambda + Example: + To(MyMethod, 0, 12, 0.5f); + Where MyMethod is a function that accepts a float parameter (which will be the result of the virtual tween) + The action to perform with the tweened value + The value to start from + The end value to reach + The duration of the virtual tween + + + + Punches a Vector3 towards the given direction and then back to the starting one + as if it was connected to the starting position via an elastic. + This tween type generates some GC allocations at startup + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The direction and strength of the punch + The duration of the tween + Indicates how much will the punch vibrate + Represents how much (0 to 1) the vector will go beyond the starting position when bouncing backwards. + 1 creates a full oscillation between the direction and the opposite decaying direction, + while 0 oscillates only between the starting position and the decaying direction + + + Shakes a Vector3 with the given values. + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The duration of the tween + The shake strength + Indicates how much will the shake vibrate + Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + Setting it to 0 will shake along a single direction and behave like a random punch. + If TRUE only shakes on the X Y axis (looks better with things like cameras). + If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + Randomness mode + + + Shakes a Vector3 with the given values. + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The duration of the tween + The shake strength on each axis + Indicates how much will the shake vibrate + Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + Setting it to 0 will shake along a single direction and behave like a random punch. + If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + Randomness mode + + + Tweens a property or field to the given values using default plugins. + Ease is applied between each segment and not as a whole. + This tween type generates some GC allocations at startup + A getter for the field or property to tween. + Example usage with lambda:()=> myProperty + A setter for the field or property to tween + Example usage with lambda:x=> myProperty = x + The end values to reach for each segment. This array must have the same length as durations + The duration of each segment. This array must have the same length as endValues + + + + Returns a new to be used for tween groups. + Mind that Sequences don't have a target applied automatically like Tweener creation shortcuts, + so if you want to be able to kill this Sequence when calling DOTween.Kill(target) you'll have to add + the target manually; you can do that directly by using the overload instead of this one + + + + + Returns a new to be used for tween groups, and allows to set a target + (because Sequences don't have their target set automatically like Tweener creation shortcuts). + That way killing/controlling tweens by target will apply to this Sequence too. + + The target of the Sequence. Relevant only for static target-based methods like DOTween.Kill(target), + useless otherwise + + + Completes all tweens and returns the number of actual tweens completed + (meaning tweens that don't have infinite loops and were not already complete) + For Sequences only: if TRUE also internal Sequence callbacks will be fired, + otherwise they will be ignored + + + Completes all tweens with the given ID or target and returns the number of actual tweens completed + (meaning the tweens that don't have infinite loops and were not already complete) + For Sequences only: if TRUE internal Sequence callbacks will be fired, + otherwise they will be ignored + + + Flips all tweens (changing their direction to forward if it was backwards and viceversa), + then returns the number of actual tweens flipped + + + Flips the tweens with the given ID or target (changing their direction to forward if it was backwards and viceversa), + then returns the number of actual tweens flipped + + + Sends all tweens to the given position (calculating also eventual loop cycles) and returns the actual tweens involved + + + Sends all tweens with the given ID or target to the given position (calculating also eventual loop cycles) + and returns the actual tweens involved + + + Kills all tweens and returns the number of actual tweens killed + If TRUE completes the tweens before killing them + + + Kills all tweens and returns the number of actual tweens killed + If TRUE completes the tweens before killing them + Eventual IDs or targets to exclude from the killing + + + Kills all tweens with the given ID or target and returns the number of actual tweens killed + If TRUE completes the tweens before killing them + + + Kills all tweens with the given target and the given ID, and returns the number of actual tweens killed + If TRUE completes the tweens before killing them + + + Pauses all tweens and returns the number of actual tweens paused + + + Pauses all tweens with the given ID or target and returns the number of actual tweens paused + (meaning the tweens that were actually playing and have been paused) + + + Plays all tweens and returns the number of actual tweens played + (meaning tweens that were not already playing or complete) + + + Plays all tweens with the given ID or target and returns the number of actual tweens played + (meaning the tweens that were not already playing or complete) + + + Plays all tweens with the given target and the given ID, and returns the number of actual tweens played + (meaning the tweens that were not already playing or complete) + + + Plays backwards all tweens and returns the number of actual tweens played + (meaning tweens that were not already started, playing backwards or rewinded) + + + Plays backwards all tweens with the given ID or target and returns the number of actual tweens played + (meaning the tweens that were not already started, playing backwards or rewinded) + + + Plays backwards all tweens with the given target and ID and returns the number of actual tweens played + (meaning the tweens that were not already started, playing backwards or rewinded) + + + Plays forward all tweens and returns the number of actual tweens played + (meaning tweens that were not already playing forward or complete) + + + Plays forward all tweens with the given ID or target and returns the number of actual tweens played + (meaning the tweens that were not already playing forward or complete) + + + Plays forward all tweens with the given target and ID and returns the number of actual tweens played + (meaning the tweens that were not already started, playing backwards or rewinded) + + + Restarts all tweens, then returns the number of actual tweens restarted + + + Restarts all tweens with the given ID or target, then returns the number of actual tweens restarted + If TRUE includes the eventual tweens delays, otherwise skips them + If >= 0 changes the startup delay of all involved tweens to this value, otherwise doesn't touch it + + + Restarts all tweens with the given target and the given ID, and returns the number of actual tweens played + (meaning the tweens that were not already playing or complete) + If TRUE includes the eventual tweens delays, otherwise skips them + If >= 0 changes the startup delay of all involved tweens to this value, otherwise doesn't touch it + + + Rewinds and pauses all tweens, then returns the number of actual tweens rewinded + (meaning tweens that were not already rewinded) + + + Rewinds and pauses all tweens with the given ID or target, then returns the number of actual tweens rewinded + (meaning the tweens that were not already rewinded) + + + Smoothly rewinds all tweens (delays excluded), then returns the number of actual tweens rewinding/rewinded + (meaning tweens that were not already rewinded). + A "smooth rewind" animates the tween to its start position, + skipping all elapsed loops (except in case of LoopType.Incremental) while keeping the animation fluent. + Note that a tween that was smoothly rewinded will have its play direction flipped + + + Smoothly rewinds all tweens (delays excluded) with the given ID or target, then returns the number of actual tweens rewinding/rewinded + (meaning the tweens that were not already rewinded). + A "smooth rewind" animates the tween to its start position, + skipping all elapsed loops (except in case of LoopType.Incremental) while keeping the animation fluent. + Note that a tween that was smoothly rewinded will have its play direction flipped + + + Toggles the play state of all tweens and returns the number of actual tweens toggled + (meaning tweens that could be played or paused, depending on the toggle state) + + + Toggles the play state of all tweens with the given ID or target and returns the number of actual tweens toggled + (meaning the tweens that could be played or paused, depending on the toggle state) + + + + Returns TRUE if a tween with the given ID or target is active. + You can also use this to know if a shortcut tween is active for a given target. + Example: + transform.DOMoveX(45, 1); // transform is automatically added as the tween target + DOTween.IsTweening(transform); // Returns true + + The target or ID to look for + If FALSE (default) returns TRUE as long as a tween for the given target/ID is active, + otherwise also requires it to be playing + + + + Returns the total number of active tweens (so both Tweeners and Sequences). + A tween is considered active if it wasn't killed, regardless if it's playing or paused + + + + + Returns the total number of active Tweeners. + A Tweener is considered active if it wasn't killed, regardless if it's playing or paused + + + + + Returns the total number of active Sequences. + A Sequence is considered active if it wasn't killed, regardless if it's playing or paused + + + + + Returns the total number of active and playing tweens. + A tween is considered as playing even if its delay is actually playing + + + + + Returns a the total number of active tweens with the given id. + + If TRUE returns only the tweens with the given ID that are currently playing + + + + Returns a list of all active tweens in a playing state. + Returns NULL if there are no active playing tweens. + Beware: each time you call this method a new list is generated, so use it for debug only + + If NULL creates a new list, otherwise clears and fills this one (and thus saves allocations) + + + + Returns a list of all active tweens in a paused state. + Returns NULL if there are no active paused tweens. + Beware: each time you call this method a new list is generated, so use it for debug only + + If NULL creates a new list, otherwise clears and fills this one (and thus saves allocations) + + + + Returns a list of all active tweens with the given id. + Returns NULL if there are no active tweens with the given id. + Beware: each time you call this method a new list is generated + + If TRUE returns only the tweens with the given ID that are currently playing + If NULL creates a new list, otherwise clears and fills this one (and thus saves allocations) + + + + Returns a list of all active tweens with the given target. + Returns NULL if there are no active tweens with the given target. + Beware: each time you call this method a new list is generated + If TRUE returns only the tweens with the given target that are currently playing + If NULL creates a new list, otherwise clears and fills this one (and thus saves allocations) + + + + + Creates virtual tweens that can be used to change other elements via their OnUpdate calls + + + + + Tweens a virtual float. + You can add regular settings to the generated tween, + but do not use OnUpdate or you will overwrite the onVirtualUpdate parameter + + The value to start from + The value to tween to + The duration of the tween + A callback which must accept a parameter of type float, called at each update + + + + Tweens a virtual int. + You can add regular settings to the generated tween, + but do not use OnUpdate or you will overwrite the onVirtualUpdate parameter + + The value to start from + The value to tween to + The duration of the tween + A callback which must accept a parameter of type int, called at each update + + + + Tweens a virtual Vector2. + You can add regular settings to the generated tween, + but do not use OnUpdate or you will overwrite the onVirtualUpdate parameter + + The value to start from + The value to tween to + The duration of the tween + A callback which must accept a parameter of type Vector3, called at each update + + + + Tweens a virtual Vector3. + You can add regular settings to the generated tween, + but do not use OnUpdate or you will overwrite the onVirtualUpdate parameter + + The value to start from + The value to tween to + The duration of the tween + A callback which must accept a parameter of type Vector3, called at each update + + + + Tweens a virtual Color. + You can add regular settings to the generated tween, + but do not use OnUpdate or you will overwrite the onVirtualUpdate parameter + + The value to start from + The value to tween to + The duration of the tween + A callback which must accept a parameter of type Color, called at each update + + + Returns a value based on the given ease and lifetime percentage (0 to 1) + The value to start from when lifetimePercentage is 0 + The value to reach when lifetimePercentage is 1 + The time percentage (0 to 1) at which the value should be taken + The type of ease + + + Returns a value based on the given ease and lifetime percentage (0 to 1) + The value to start from when lifetimePercentage is 0 + The value to reach when lifetimePercentage is 1 + The time percentage (0 to 1) at which the value should be taken + The type of ease + Eventual overshoot to use with Back ease + + + Returns a value based on the given ease and lifetime percentage (0 to 1) + The value to start from when lifetimePercentage is 0 + The value to reach when lifetimePercentage is 1 + The time percentage (0 to 1) at which the value should be taken + The type of ease + Eventual amplitude to use with Elastic easeType + Eventual period to use with Elastic easeType + + + Returns a value based on the given ease and lifetime percentage (0 to 1) + The value to start from when lifetimePercentage is 0 + The value to reach when lifetimePercentage is 1 + The time percentage (0 to 1) at which the value should be taken + The AnimationCurve to use for ease + + + Returns a value based on the given ease and lifetime percentage (0 to 1) + The value to start from when lifetimePercentage is 0 + The value to reach when lifetimePercentage is 1 + The time percentage (0 to 1) at which the value should be taken + The type of ease + + + Returns a value based on the given ease and lifetime percentage (0 to 1) + The value to start from when lifetimePercentage is 0 + The value to reach when lifetimePercentage is 1 + The time percentage (0 to 1) at which the value should be taken + The type of ease + Eventual overshoot to use with Back ease + + + Returns a value based on the given ease and lifetime percentage (0 to 1) + The value to start from when lifetimePercentage is 0 + The value to reach when lifetimePercentage is 1 + The time percentage (0 to 1) at which the value should be taken + The type of ease + Eventual amplitude to use with Elastic easeType + Eventual period to use with Elastic easeType + + + Returns a value based on the given ease and lifetime percentage (0 to 1) + The value to start from when lifetimePercentage is 0 + The value to reach when lifetimePercentage is 1 + The time percentage (0 to 1) at which the value should be taken + The AnimationCurve to use for ease + + + Fires the given callback after the given time. + Callback delay + Callback to fire when the delay has expired + If TRUE (default) ignores Unity's timeScale + + + + Don't assign this! It's assigned automatically when creating 0 duration tweens + + + + + Don't assign this! It's assigned automatically when setting the ease to an AnimationCurve or to a custom ease function + + + + + Allows to wrap ease method in special ways, adding extra features + + + + + Converts the given ease so that it also creates a stop-motion effect, by playing the tween at the given FPS + + FPS at which the tween should be played + Ease type + + + + Converts the given ease so that it also creates a stop-motion effect, by playing the tween at the given FPS + + FPS at which the tween should be played + AnimationCurve to use for the ease + + + + Converts the given ease so that it also creates a stop-motion effect, by playing the tween at the given FPS + + FPS at which the tween should be played + Custom ease function to use + + + + Used to allow method chaining with DOTween.Init + + + + + Directly sets the current max capacity of Tweeners and Sequences + (meaning how many Tweeners and Sequences can be running at the same time), + so that DOTween doesn't need to automatically increase them in case the max is reached + (which might lead to hiccups when that happens). + Sequences capacity must be less or equal to Tweeners capacity + (if you pass a low Tweener capacity it will be automatically increased to match the Sequence's). + Beware: use this method only when there are no tweens running. + + Max Tweeners capacity. + Default: 200 + Max Sequences capacity. + Default: 50 + + + + Behaviour that can be assigned when chaining a SetLink to a tween + + + + Pauses the tween when the link target is disabled + + + Pauses the tween when the link target is disabled, plays it when it's enabled + + + Pauses the tween when the link target is disabled, restarts it when it's enabled + + + Plays the tween when the link target is enabled + + + Restarts the tween when the link target is enabled + + + Kills the tween when the link target is disabled + + + Kills the tween when the link target is destroyed (becomes NULL). This is always active even if another behaviour is chosen + + + Completes the tween when the link target is disabled + + + Completes and kills the tween when the link target is disabled + + + Rewinds the tween (delay excluded) when the link target is disabled + + + Rewinds and kills the tween when the link target is disabled + + + + Path mode (used to determine correct LookAt orientation) + + + + Ignores the path mode (and thus LookAt behaviour) + + + Regular 3D path + + + 2D top-down path + + + 2D side-scroller path + + + + Type of path to use with DOPath tweens + + + + Linear, composed of straight segments between each waypoint + + + Curved path (which uses Catmull-Rom curves) + + + EXPERIMENTAL: Curved path (which uses Cubic Bezier curves, where each point requires two extra control points) + + + + Tweens a Vector2 along a circle. + EndValue represents the center of the circle, start and end value degrees are inside options + ChangeValue x is changeValue°, y is unused + + + + + Path control point + + + + + Path waypoints (modified by PathPlugin when setting relative end/change value or by CubicBezierDecoder) and by DOTweenPathInspector + + + + + Minimum input points necessary to create the path (doesn't correspond to actual waypoints required) + + + + + Gets the point on the path at the given percentage (0 to 1) + + The percentage (0 to 1) at which to get the point + If TRUE constant speed is taken into account, otherwise not + + + + Base interface for all tween plugins options + + + + Resets the plugin + + + + This plugin generates some GC allocations at startup + + + + + Path plugin works exclusively with Transforms + + + + + Rotation mode used with DORotate methods + + + + + Fastest way that never rotates beyond 360° + + + + + Fastest way that rotates beyond 360° + + + + + Adds the given rotation to the transform using world axis and an advanced precision mode + (like when using transform.Rotate(Space.World)). + In this mode the end value is is always considered relative + + + + + Adds the given rotation to the transform's local axis + (like when rotating an object with the "local" switch enabled in Unity's editor or using transform.Rotate(Space.Self)). + In this mode the end value is is always considered relative + + + + + Type of scramble to apply to string tweens + + + + + No scrambling of characters + + + + + A-Z + a-z + 0-9 characters + + + + + A-Z characters + + + + + a-z characters + + + + + 0-9 characters + + + + + Custom characters + + + + + Type of randomness to apply to a shake tween + + + + Default, full randomness + + + Creates a more balanced randomness that looks more harmonic + + + + Methods that extend Tween objects and allow to control or get data from them + + + + Completes the tween + + + Completes the tween + For Sequences only: if TRUE also internal Sequence callbacks will be fired, + otherwise they will be ignored + + + Optional: indicates that the tween creation has ended, to be used (optionally) as the last element of tween chaining creation.
+ This method won't do anything except in case of 0-duration tweens, + where it will complete them immediately instead of waiting for the next internal update routine + (unless they're nested in a Sequence, in which case the Sequence will still be the one in control and this method will be ignored) + + + Flips the direction of this tween (backwards if it was going forward or viceversa) + + + Forces the tween to initialize its settings immediately + + + Send the tween to the given position in time + Time position to reach + (if higher than the whole tween duration the tween will simply reach its end) + If TRUE will play the tween after reaching the given position, otherwise it will pause it + + + Send the tween to the given position in time while also executing any callback between the previous time position and the new one + Time position to reach + (if higher than the whole tween duration the tween will simply reach its end) + If TRUE will play the tween after reaching the given position, otherwise it will pause it + + + Kills the tween + If TRUE completes the tween before killing it + + + + Forces this tween to update manually, regardless of the set via SetUpdate. + Note that the tween will still be subject to normal tween rules, so if for example it's paused this method will do nothing. + Also note that if you only want to update this tween instance manually you'll have to set it to anyway, + so that it's not updated automatically. + + Manual deltaTime + Unscaled delta time (used with tweens set as timeScaleIndependent) + + + Pauses the tween + + + Plays the tween + + + Sets the tween in a backwards direction and plays it + + + Sets the tween in a forward direction and plays it + + + Restarts the tween from the beginning + Ignored in case of Sequences. If TRUE includes the eventual tween delay, otherwise skips it + Ignored in case of Sequences. If >= 0 changes the startup delay to this value, otherwise doesn't touch it + + + Rewinds and pauses the tween + Ignored in case of Sequences. If TRUE includes the eventual tween delay, otherwise skips it + + + Smoothly rewinds the tween (delays excluded). + A "smooth rewind" animates the tween to its start position, + skipping all elapsed loops (except in case of LoopType.Incremental) while keeping the animation fluent. + If called on a tween who is still waiting for its delay to happen, it will simply set the delay to 0 and pause the tween. + Note that a tween that was smoothly rewinded will have its play direction flipped + + + Plays the tween if it was paused, pauses it if it was playing + + + Send a path tween to the given waypoint. + Has no effect if this is not a path tween. + BEWARE, this is a special utility method: + it works only with Linear eases. Also, the lookAt direction might be wrong after calling this and might need to be set manually + (because it relies on a smooth path movement and doesn't work well with jumps that encompass dramatic direction changes) + Waypoint index to reach + (if higher than the max waypoint index the tween will simply go to the last one) + If TRUE will play the tween after reaching the given waypoint, otherwise it will pause it + + + + Creates a yield instruction that waits until the tween is killed or complete. + It can be used inside a coroutine as a yield. + Example usage:yield return myTween.WaitForCompletion(); + + + + + Creates a yield instruction that waits until the tween is killed or rewinded. + It can be used inside a coroutine as a yield. + Example usage:yield return myTween.WaitForRewind(); + + + + + Creates a yield instruction that waits until the tween is killed. + It can be used inside a coroutine as a yield. + Example usage:yield return myTween.WaitForKill(); + + + + + Creates a yield instruction that waits until the tween is killed or has gone through the given amount of loops. + It can be used inside a coroutine as a yield. + Example usage:yield return myTween.WaitForElapsedLoops(2); + + Elapsed loops to wait for + + + + Creates a yield instruction that waits until the tween is killed or has reached the given position (loops included, delays excluded). + It can be used inside a coroutine as a yield. + Example usage:yield return myTween.WaitForPosition(2.5f); + + Position (loops included, delays excluded) to wait for + + + + Creates a yield instruction that waits until the tween is killed or started + (meaning when the tween is set in a playing state the first time, after any eventual delay). + It can be used inside a coroutine as a yield. + Example usage:yield return myTween.WaitForStart(); + + + + Returns the total number of loops completed by this tween + + + Returns the eventual delay set for this tween + + + Returns the eventual elapsed delay set for this tween + + + Returns the duration of this tween (delays excluded). + NOTE: when using settings like SpeedBased, the duration will be recalculated when the tween starts + If TRUE returns the full duration loops included, + otherwise the duration of a single loop cycle + + + Returns the elapsed time for this tween (delays exluded) + If TRUE returns the elapsed time since startup loops included, + otherwise the elapsed time within the current loop cycle + + + Returns the elapsed percentage (0 to 1) of this tween (delays exluded) + If TRUE returns the elapsed percentage since startup loops included, + otherwise the elapsed percentage within the current loop cycle + + + Returns the elapsed percentage (0 to 1) of this tween (delays exluded), + based on a single loop, and calculating eventual backwards Yoyo loops as 1 to 0 instead of 0 to 1 + + + Returns FALSE if this tween has been killed or is NULL, TRUE otherwise. + BEWARE: if this tween is recyclable it might have been spawned again for another use and thus return TRUE anyway. + When working with recyclable tweens you should take care to know when a tween has been killed and manually set your references to NULL. + If you want to be sure your references are set to NULL when a tween is killed you can use the OnKill callback like this: + .OnKill(()=> myTweenReference = null) + + + Returns TRUE if this tween was reversed and is set to go backwards + + + NOTE: To check if a tween was simply set to go backwards see . + Returns TRUE if this tween is going backwards for any of these reasons: + - The tween was reversed and is going backwards on a straight loop + - The tween was reversed and is going backwards on an odd Yoyo loop + - The tween is going forward but on an even Yoyo loop + IMPORTANT: if used inside a tween's callback, this will return a result concerning the exact frame when it's asked, + so for example in a callback at the end of a Yoyo loop step this method will never return FALSE + because the frame will never end exactly there and the tween will already be going backwards when the callback is fired + + + Returns TRUE if the tween is complete + (silently fails and returns FALSE if the tween has been killed) + + + Returns TRUE if this tween was set to be timeScale independent via the tween.SetUpdate method + + + Returns TRUE if this tween has been initialized + + + Returns TRUE if this tween is playing + + + Returns the total number of loops set for this tween + (returns -1 if the loops are infinite) + + + + Returns a point on a path based on the given path percentage. + Returns Vector3.zero if this is not a path tween, if the tween is invalid, or if the path is not yet initialized. + A path is initialized after its tween starts, or immediately if the tween was created with the Path Editor (DOTween Pro feature). + You can force a path to be initialized by calling myTween.ForceInit(). + + Percentage of the path (0 to 1) on which to get the point + + + + Returns an array of points that can be used to draw the path. + Note that this method generates allocations, because it creates a new array. + Returns NULL if this is not a path tween, if the tween is invalid, or if the path is not yet initialized. + A path is initialized after its tween starts, or immediately if the tween was created with the Path Editor (DOTween Pro feature). + You can force a path to be initialized by calling myTween.ForceInit(). + + How many points to create for each path segment (waypoint to waypoint). + Only used in case of non-Linear paths + + + + Returns the length of a path. + Returns -1 if this is not a path tween, if the tween is invalid, or if the path is not yet initialized. + A path is initialized after its tween starts, or immediately if the tween was created with the Path Editor (DOTween Pro feature). + You can force a path to be initialized by calling myTween.ForceInit(). + + + + + Types of loop + + + + Each loop cycle restarts from the beginning + + + The tween moves forward and backwards at alternate cycles + + + Continuously increments the tween at the end of each loop cycle (A to B, B to B+(A-B), and so on), thus always moving "onward". + In case of String tweens works only if the tween is set as relative + + + + Controls other tweens as a group + + + + + Methods that extend known Unity objects and allow to directly create and control tweens from their instances + + + + Tweens a Camera's aspect to the given value. + Also stores the camera as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Camera's backgroundColor to the given value. + Also stores the camera as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Camera's farClipPlane to the given value. + Also stores the camera as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Camera's fieldOfView to the given value. + Also stores the camera as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Camera's nearClipPlane to the given value. + Also stores the camera as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Camera's orthographicSize to the given value. + Also stores the camera as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Camera's pixelRect to the given value. + Also stores the camera as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Camera's rect to the given value. + Also stores the camera as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Shakes a Camera's localPosition along its relative X Y axes with the given values. + Also stores the camera as the tween's target so it can be used for filtered operations + The duration of the tween + The shake strength + Indicates how much will the shake vibrate + Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + Setting it to 0 will shake along a single direction. + If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + Randomness mode + + + Shakes a Camera's localPosition along its relative X Y axes with the given values. + Also stores the camera as the tween's target so it can be used for filtered operations + The duration of the tween + The shake strength on each axis + Indicates how much will the shake vibrate + Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + Setting it to 0 will shake along a single direction. + If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + Randomness mode + + + Shakes a Camera's localRotation. + Also stores the camera as the tween's target so it can be used for filtered operations + The duration of the tween + The shake strength + Indicates how much will the shake vibrate + Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + Setting it to 0 will shake along a single direction. + If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + Randomness mode + + + Shakes a Camera's localRotation. + Also stores the camera as the tween's target so it can be used for filtered operations + The duration of the tween + The shake strength on each axis + Indicates how much will the shake vibrate + Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + Setting it to 0 will shake along a single direction. + If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + Randomness mode + + + Tweens a Light's color to the given value. + Also stores the light as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Light's intensity to the given value. + Also stores the light as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Light's shadowStrength to the given value. + Also stores the light as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a LineRenderer's color to the given value. + Also stores the LineRenderer as the tween's target so it can be used for filtered operations. + Note that this method requires to also insert the start colors for the tween, + since LineRenderers have no way to get them. + The start value to tween from + The end value to reachThe duration of the tween + + + Tweens a Material's color to the given value. + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Material's named color property to the given value. + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reach + The name of the material property to tween (like _Tint or _SpecColor) + The duration of the tween + + + Tweens a Material's named color property with the given ID to the given value. + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reach + The ID of the material property to tween (also called nameID in Unity's manual) + The duration of the tween + + + Tweens a Material's alpha color to the given value + (will have no effect unless your material supports transparency). + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Material's alpha color to the given value + (will have no effect unless your material supports transparency). + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reach + The name of the material property to tween (like _Tint or _SpecColor) + The duration of the tween + + + Tweens a Material's alpha color with the given ID to the given value + (will have no effect unless your material supports transparency). + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reach + The ID of the material property to tween (also called nameID in Unity's manual) + The duration of the tween + + + Tweens a Material's named float property to the given value. + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reach + The name of the material property to tween + The duration of the tween + + + Tweens a Material's named float property with the given ID to the given value. + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reach + The ID of the material property to tween (also called nameID in Unity's manual) + The duration of the tween + + + Tweens a Material's texture offset to the given value. + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reach + The duration of the tween + + + Tweens a Material's named texture offset property to the given value. + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reach + The name of the material property to tween + The duration of the tween + + + Tweens a Material's texture scale to the given value. + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reach + The duration of the tween + + + Tweens a Material's named texture scale property to the given value. + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reach + The name of the material property to tween + The duration of the tween + + + Tweens a Material's named Vector property to the given value. + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reach + The name of the material property to tween + The duration of the tween + + + Tweens a Material's named Vector property with the given ID to the given value. + Also stores the material as the tween's target so it can be used for filtered operations + The end value to reach + The ID of the material property to tween (also called nameID in Unity's manual) + The duration of the tween + + + Tweens a TrailRenderer's startWidth/endWidth to the given value. + Also stores the TrailRenderer as the tween's target so it can be used for filtered operations + The end startWidth to reachThe end endWidth to reach + The duration of the tween + + + Tweens a TrailRenderer's time to the given value. + Also stores the TrailRenderer as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Transform's position to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + If TRUE the tween will smoothly snap all values to integers + + + Tweens a Transform's X position to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + If TRUE the tween will smoothly snap all values to integers + + + Tweens a Transform's Y position to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + If TRUE the tween will smoothly snap all values to integers + + + Tweens a Transform's Z position to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + If TRUE the tween will smoothly snap all values to integers + + + Tweens a Transform's localPosition to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + If TRUE the tween will smoothly snap all values to integers + + + Tweens a Transform's X localPosition to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + If TRUE the tween will smoothly snap all values to integers + + + Tweens a Transform's Y localPosition to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + If TRUE the tween will smoothly snap all values to integers + + + Tweens a Transform's Z localPosition to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + If TRUE the tween will smoothly snap all values to integers + + + Tweens a Transform's rotation to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + Rotation mode + + + Tweens a Transform's rotation to the given value using pure quaternion values. + Also stores the transform as the tween's target so it can be used for filtered operations. + PLEASE NOTE: DORotate, which takes Vector3 values, is the preferred rotation method. + This method was implemented for very special cases, and doesn't support LoopType.Incremental loops + (neither for itself nor if placed inside a LoopType.Incremental Sequence) + + The end value to reachThe duration of the tween + + + Tweens a Transform's localRotation to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + Rotation mode + + + Tweens a Transform's rotation to the given value using pure quaternion values. + Also stores the transform as the tween's target so it can be used for filtered operations. + PLEASE NOTE: DOLocalRotate, which takes Vector3 values, is the preferred rotation method. + This method was implemented for very special cases, and doesn't support LoopType.Incremental loops + (neither for itself nor if placed inside a LoopType.Incremental Sequence) + + The end value to reachThe duration of the tween + + + Tweens a Transform's localScale to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Transform's localScale uniformly to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Transform's X localScale to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Transform's Y localScale to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Transform's Z localScale to the given value. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Transform's rotation so that it will look towards the given world position. + Also stores the transform as the tween's target so it can be used for filtered operations + The position to look atThe duration of the tween + Eventual axis constraint for the rotation + The vector that defines in which direction up is (default: Vector3.up) + + + EXPERIMENTAL Tweens a Transform's rotation so that it will look towards the given world position, + while also updating the lookAt position every frame + (contrary to which calculates the lookAt rotation only once, when the tween starts). + Also stores the transform as the tween's target so it can be used for filtered operations + The position to look atThe duration of the tween + Eventual axis constraint for the rotation + The vector that defines in which direction up is (default: Vector3.up) + + + Punches a Transform's localPosition towards the given direction and then back to the starting one + as if it was connected to the starting position via an elastic. + The direction and strength of the punch (added to the Transform's current position) + The duration of the tween + Indicates how much will the punch vibrate + Represents how much (0 to 1) the vector will go beyond the starting position when bouncing backwards. + 1 creates a full oscillation between the punch direction and the opposite direction, + while 0 oscillates only between the punch and the start position + If TRUE the tween will smoothly snap all values to integers + + + Punches a Transform's localScale towards the given size and then back to the starting one + as if it was connected to the starting scale via an elastic. + The punch strength (added to the Transform's current scale) + The duration of the tween + Indicates how much will the punch vibrate + Represents how much (0 to 1) the vector will go beyond the starting size when bouncing backwards. + 1 creates a full oscillation between the punch scale and the opposite scale, + while 0 oscillates only between the punch scale and the start scale + + + Punches a Transform's localRotation towards the given size and then back to the starting one + as if it was connected to the starting rotation via an elastic. + The punch strength (added to the Transform's current rotation) + The duration of the tween + Indicates how much will the punch vibrate + Represents how much (0 to 1) the vector will go beyond the starting rotation when bouncing backwards. + 1 creates a full oscillation between the punch rotation and the opposite rotation, + while 0 oscillates only between the punch and the start rotation + + + Shakes a Transform's localPosition with the given values. + The duration of the tween + The shake strength + Indicates how much will the shake vibrate + Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + Setting it to 0 will shake along a single direction. + If TRUE the tween will smoothly snap all values to integers + If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + Randomness mode + + + Shakes a Transform's localPosition with the given values. + The duration of the tween + The shake strength on each axis + Indicates how much will the shake vibrate + Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + Setting it to 0 will shake along a single direction. + If TRUE the tween will smoothly snap all values to integers + If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + Randomness mode + + + Shakes a Transform's localRotation. + The duration of the tween + The shake strength + Indicates how much will the shake vibrate + Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + Setting it to 0 will shake along a single direction. + If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + Randomness mode + + + Shakes a Transform's localRotation. + The duration of the tween + The shake strength on each axis + Indicates how much will the shake vibrate + Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + Setting it to 0 will shake along a single direction. + If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + Randomness mode + + + Shakes a Transform's localScale. + The duration of the tween + The shake strength + Indicates how much will the shake vibrate + Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + Setting it to 0 will shake along a single direction. + If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + Randomness mode + + + Shakes a Transform's localScale. + The duration of the tween + The shake strength on each axis + Indicates how much will the shake vibrate + Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + Setting it to 0 will shake along a single direction. + If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + Randomness mode + + + Tweens a Transform's position to the given value, while also applying a jump effect along the Y axis. + Returns a Sequence instead of a Tweener. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reach + Power of the jump (the max height of the jump is represented by this plus the final Y offset) + Total number of jumps + The duration of the tween + If TRUE the tween will smoothly snap all values to integers + + + Tweens a Transform's localPosition to the given value, while also applying a jump effect along the Y axis. + Returns a Sequence instead of a Tweener. + Also stores the transform as the tween's target so it can be used for filtered operations + The end value to reach + Power of the jump (the max height of the jump is represented by this plus the final Y offset) + Total number of jumps + The duration of the tween + If TRUE the tween will smoothly snap all values to integers + + + Tweens a Transform's position through the given path waypoints, using the chosen path algorithm. + Also stores the transform as the tween's target so it can be used for filtered operations + The waypoints to go through + The duration of the tween + The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points) + The path mode: 3D, side-scroller 2D, top-down 2D + The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved paths but are more expensive. + Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints + The color of the path (shown when gizmos are active in the Play panel and the tween is running) + + + Tweens a Transform's localPosition through the given path waypoints, using the chosen path algorithm. + Also stores the transform as the tween's target so it can be used for filtered operations + The waypoint to go through + The duration of the tween + The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points) + The path mode: 3D, side-scroller 2D, top-down 2D + The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive. + Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints + The color of the path (shown when gizmos are active in the Play panel and the tween is running) + + + IMPORTANT: Unless you really know what you're doing, you should use the overload that accepts a Vector3 array instead. + Tweens a Transform's position via the given path. + Also stores the transform as the tween's target so it can be used for filtered operations + The path to use + The duration of the tween + The path mode: 3D, side-scroller 2D, top-down 2D + + + IMPORTANT: Unless you really know what you're doing, you should use the overload that accepts a Vector3 array instead. + Tweens a Transform's localPosition via the given path. + Also stores the transform as the tween's target so it can be used for filtered operations + The path to use + The duration of the tween + The path mode: 3D, side-scroller 2D, top-down 2D + + + Tweens a Tween's timeScale to the given value. + Also stores the Tween as the tween's target so it can be used for filtered operations + The end value to reachThe duration of the tween + + + Tweens a Light's color to the given value, + in a way that allows other DOBlendableColor tweens to work together on the same target, + instead than fight each other as multiple DOColor would do. + Also stores the Light as the tween's target so it can be used for filtered operations + The value to tween toThe duration of the tween + + + Tweens a Material's color to the given value, + in a way that allows other DOBlendableColor tweens to work together on the same target, + instead than fight each other as multiple DOColor would do. + Also stores the Material as the tween's target so it can be used for filtered operations + The value to tween toThe duration of the tween + + + Tweens a Material's named color property to the given value, + in a way that allows other DOBlendableColor tweens to work together on the same target, + instead than fight each other as multiple DOColor would do. + Also stores the Material as the tween's target so it can be used for filtered operations + The value to tween to + The name of the material property to tween (like _Tint or _SpecColor) + The duration of the tween + + + Tweens a Material's named color property with the given ID to the given value, + in a way that allows other DOBlendableColor tweens to work together on the same target, + instead than fight each other as multiple DOColor would do. + Also stores the Material as the tween's target so it can be used for filtered operations + The value to tween to + The ID of the material property to tween (also called nameID in Unity's manual) + The duration of the tween + + + Tweens a Transform's position BY the given value (as if you chained a SetRelative), + in a way that allows other DOBlendableMove tweens to work together on the same target, + instead than fight each other as multiple DOMove would do. + Also stores the transform as the tween's target so it can be used for filtered operations + The value to tween byThe duration of the tween + If TRUE the tween will smoothly snap all values to integers + + + Tweens a Transform's localPosition BY the given value (as if you chained a SetRelative), + in a way that allows other DOBlendableMove tweens to work together on the same target, + instead than fight each other as multiple DOMove would do. + Also stores the transform as the tween's target so it can be used for filtered operations + The value to tween byThe duration of the tween + If TRUE the tween will smoothly snap all values to integers + + + EXPERIMENTAL METHOD - Tweens a Transform's rotation BY the given value (as if you chained a SetRelative), + in a way that allows other DOBlendableRotate tweens to work together on the same target, + instead than fight each other as multiple DORotate would do. + Also stores the transform as the tween's target so it can be used for filtered operations + The value to tween byThe duration of the tween + Rotation mode + + + EXPERIMENTAL METHOD - Tweens a Transform's lcoalRotation BY the given value (as if you chained a SetRelative), + in a way that allows other DOBlendableRotate tweens to work together on the same target, + instead than fight each other as multiple DORotate would do. + Also stores the transform as the tween's target so it can be used for filtered operations + The value to tween byThe duration of the tween + Rotation mode + + + Punches a Transform's localRotation BY the given value and then back to the starting one + as if it was connected to the starting rotation via an elastic. Does it in a way that allows other + DOBlendableRotate tweens to work together on the same target + The punch strength (added to the Transform's current rotation) + The duration of the tween + Indicates how much will the punch vibrate + Represents how much (0 to 1) the vector will go beyond the starting rotation when bouncing backwards. + 1 creates a full oscillation between the punch rotation and the opposite rotation, + while 0 oscillates only between the punch and the start rotation + + + Tweens a Transform's localScale BY the given value (as if you chained a SetRelative), + in a way that allows other DOBlendableScale tweens to work together on the same target, + instead than fight each other as multiple DOScale would do. + Also stores the transform as the tween's target so it can be used for filtered operations + The value to tween byThe duration of the tween + + + + Completes all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens completed + (meaning the tweens that don't have infinite loops and were not already complete) + + For Sequences only: if TRUE also internal Sequence callbacks will be fired, + otherwise they will be ignored + + + + Completes all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens completed + (meaning the tweens that don't have infinite loops and were not already complete) + + For Sequences only: if TRUE also internal Sequence callbacks will be fired, + otherwise they will be ignored + + + + Kills all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens killed. + + If TRUE completes the tween before killing it + + + + Kills all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens killed. + + If TRUE completes the tween before killing it + + + + Flips the direction (backwards if it was going forward or viceversa) of all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens flipped. + + + + + Flips the direction (backwards if it was going forward or viceversa) of all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens flipped. + + + + + Sends to the given position all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens involved. + + Time position to reach + (if higher than the whole tween duration the tween will simply reach its end) + If TRUE will play the tween after reaching the given position, otherwise it will pause it + + + + Sends to the given position all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens involved. + + Time position to reach + (if higher than the whole tween duration the tween will simply reach its end) + If TRUE will play the tween after reaching the given position, otherwise it will pause it + + + + Pauses all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens paused. + + + + + Pauses all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens paused. + + + + + Plays all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens played. + + + + + Plays all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens played. + + + + + Plays backwards all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens played. + + + + + Plays backwards all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens played. + + + + + Plays forward all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens played. + + + + + Plays forward all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens played. + + + + + Restarts all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens restarted. + + + + + Restarts all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens restarted. + + + + + Rewinds all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens rewinded. + + + + + Rewinds all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens rewinded. + + + + + Smoothly rewinds all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens rewinded. + + + + + Smoothly rewinds all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens rewinded. + + + + + Toggles the paused state (plays if it was paused, pauses if it was playing) of all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens involved. + + + + + Toggles the paused state (plays if it was paused, pauses if it was playing) of all tweens that have this target as a reference + (meaning tweens that were started from this target, or that had this target added as an Id) + and returns the total number of tweens involved. + + + + + This class serves only as a utility class to store tween settings to apply on multiple tweens. + It is in no way needed otherwise, since you can directly apply tween settings to a tween via chaining + + + + A variable you can eventually Clear and reuse when needed, + to avoid instantiating TweenParams objects + + + Creates a new TweenParams object, which you can use to store tween settings + to pass to multiple tweens via myTween.SetAs(myTweenParms) + + + Clears and resets this TweenParams instance using default values, + so it can be reused without instantiating another one + + + Sets the autoKill behaviour of the tween. + Has no effect if the tween has already started + If TRUE the tween will be automatically killed when complete + + + Sets an ID for the tween, which can then be used as a filter with DOTween's static methods. + The ID to assign to this tween. Can be an int, a string, an object or anything else. + + + Sets an ID for the tween, which can then be used as a filter with DOTween's static methods. + The ID to assign to this tween. Can be an int, a string, an object or anything else. + + + Sets an ID for the tween, which can then be used as a filter with DOTween's static methods. + The ID to assign to this tween. Can be an int, a string, an object or anything else. + + + Sets the target for the tween, which can then be used as a filter with DOTween's static methods. + IMPORTANT: use it with caution. If you just want to set an ID for the tween use SetId instead. + When using shorcuts the shortcut target is already assigned as the tween's target, + so using this method will overwrite it and prevent shortcut-operations like myTarget.DOPause from working correctly. + The target to assign to this tween. Can be an int, a string, an object or anything else. + + + Sets the looping options for the tween. + Has no effect if the tween has already started + Number of cycles to play (-1 for infinite - will be converted to 1 in case the tween is nested in a Sequence) + Loop behaviour type (default: LoopType.Restart) + + + Sets the ease of the tween. + If applied to Sequences eases the whole sequence animation + Eventual overshoot or amplitude to use with Back or Elastic easeType (default is 1.70158) + Eventual period to use with Elastic easeType (default is 0) + + + Sets the ease of the tween using an AnimationCurve. + If applied to Sequences eases the whole sequence animation + + + Sets the ease of the tween using a custom ease function. + If applied to Sequences eases the whole sequence animation + + + Sets the recycling behaviour for the tween. + If TRUE the tween will be recycled after being killed, otherwise it will be destroyed. + + + Sets the update type to the one defined in DOTween.defaultUpdateType (UpdateType.Normal unless changed) + and lets you choose if it should be independent from Unity's Time.timeScale + If TRUE the tween will ignore Unity's Time.timeScale + + + Sets the type of update (default or independent) for the tween + The type of update (default: UpdateType.Normal) + If TRUE the tween will ignore Unity's Time.timeScale + + + Sets the onStart callback for the tween. + Called the first time the tween is set in a playing state, after any eventual delay + + + Sets the onPlay callback for the tween. + Called when the tween is set in a playing state, after any eventual delay. + Also called each time the tween resumes playing from a paused state + + + Sets the onRewind callback for the tween. + Called when the tween is rewinded, + either by calling Rewind or by reaching the start position while playing backwards. + Rewinding a tween that is already rewinded will not fire this callback + + + Sets the onUpdate callback for the tween. + Called each time the tween updates + + + Sets the onStepComplete callback for the tween. + Called the moment the tween completes one loop cycle, even when going backwards + + + Sets the onComplete callback for the tween. + Called the moment the tween reaches its final forward position, loops included + + + Sets the onKill callback for the tween. + Called the moment the tween is killed + + + Sets the onWaypointChange callback for the tween. + Called when a path tween reaches a new waypoint + + + Sets a delayed startup for the tween. + Has no effect on Sequences or if the tween has already started + + + If isRelative is TRUE sets the tween as relative + (the endValue will be calculated as startValue + endValue instead than being used directly). + Has no effect on Sequences or if the tween has already started + + + If isSpeedBased is TRUE sets the tween as speed based + (the duration will represent the number of units the tween moves x second). + Has no effect on Sequences, nested tweens, or if the tween has already started + + + + Methods that extend Tween objects and allow to set their parameters + + + + Sets the autoKill behaviour of the tween to TRUE. + Has no effect if the tween has already started or if it's added to a Sequence + + + Sets the autoKill behaviour of the tween. + Has no effect if the tween has already started or if it's added to a Sequence + If TRUE the tween will be automatically killed when complete + + + Sets an ID for the tween (), which can then be used as a filter with DOTween's static methods. + The ID to assign to this tween. Can be an int, a string, an object or anything else. + + + Sets a string ID for the tween (), which can then be used as a filter with DOTween's static methods. + Filtering via string is 2X faster than using an object as an ID (using the alternate obejct overload) + The string ID to assign to this tween. + + + Sets an int ID for the tween (), which can then be used as a filter with DOTween's static methods. + Filtering via int is 4X faster than via object, 2X faster than via string (using the alternate object/string overloads) + The int ID to assign to this tween. + + + Allows to link this tween to a GameObject + so that it will be automatically killed when the GameObject is destroyed. + Has no effect if the tween is added to a Sequence + The link target (unrelated to the target set via SetTarget) + + + Allows to link this tween to a GameObject and assign a behaviour depending on it. + This will also automatically kill the tween when the GameObject is destroyed. + Has no effect if the tween is added to a Sequence + The link target (unrelated to the target set via SetTarget) + The behaviour to use ( is always evaluated even if you choose another one) + + + Sets the target for the tween, which can then be used as a filter with DOTween's static methods. + IMPORTANT: use it with caution. If you just want to set an ID for the tween use SetId instead. + When using shorcuts the shortcut target is already assigned as the tween's target, + so using this method will overwrite it and prevent shortcut-operations like myTarget.DOPause from working correctly. + The target to assign to this tween. Can be an int, a string, an object or anything else. + + + Sets the looping options for the tween. + Has no effect if the tween has already started + Number of cycles to play (-1 for infinite - will be converted to 1 in case the tween is nested in a Sequence) + + + Sets the looping options for the tween. + Has no effect if the tween has already started + Number of cycles to play (-1 for infinite - will be converted to 1 in case the tween is nested in a Sequence) + Loop behaviour type (default: LoopType.Restart) + + + Sets the ease of the tween. + If applied to Sequences eases the whole sequence animation + + + Sets the ease of the tween. + If applied to Sequences eases the whole sequence animation + + Eventual overshoot to use with Back or Flash ease (default is 1.70158 - 1 for Flash). + In case of Flash ease it must be an intenger and sets the total number of flashes that will happen. + Using an even number will complete the tween on the starting value, while an odd one will complete it on the end value. + + + + Sets the ease of the tween. + If applied to Sequences eases the whole sequence animation + Eventual amplitude to use with Elastic easeType or overshoot to use with Flash easeType (default is 1.70158 - 1 for Flash). + In case of Flash ease it must be an integer and sets the total number of flashes that will happen. + Using an even number will complete the tween on the starting value, while an odd one will complete it on the end value. + + Eventual period to use with Elastic or Flash easeType (default is 0). + In case of Flash ease it indicates the power in time of the ease, and must be between -1 and 1. + 0 is balanced, 1 weakens the ease with time, -1 starts the ease weakened and gives it power towards the end. + + + + Sets the ease of the tween using an AnimationCurve. + If applied to Sequences eases the whole sequence animation + + + Sets the ease of the tween using a custom ease function (which must return a value between 0 and 1). + If applied to Sequences eases the whole sequence animation + + + Allows the tween to be recycled after being killed. + + + Sets the recycling behaviour for the tween. + If TRUE the tween will be recycled after being killed, otherwise it will be destroyed. + + + Sets the update type to UpdateType.Normal and lets you choose if it should be independent from Unity's Time.timeScale + If TRUE the tween will ignore Unity's Time.timeScale + + + Sets the type of update for the tween + The type of update (defalt: UpdateType.Normal) + + + Sets the type of update for the tween and lets you choose if it should be independent from Unity's Time.timeScale + The type of update + If TRUE the tween will ignore Unity's Time.timeScale + + + EXPERIMENTAL: inverts this tween, so that it will play from the end to the beginning + (playing it backwards will actually play it from the beginning to the end). + Has no effect if the tween has already started or if it's added to a Sequence + + + EXPERIMENTAL: inverts this tween, so that it will play from the end to the beginning + (playing it backwards will actually play it from the beginning to the end). + Has no effect if the tween has already started or if it's added to a Sequence + If TRUE the tween will be inverted, otherwise it won't + + + Sets the onStart callback for the tween, clearing any previous onStart callback that was set. + Called the first time the tween is set in a playing state, after any eventual delay + + + Sets the onPlay callback for the tween, clearing any previous onPlay callback that was set. + Called when the tween is set in a playing state, after any eventual delay. + Also called each time the tween resumes playing from a paused state + + + Sets the onPause callback for the tween, clearing any previous onPause callback that was set. + Called when the tween state changes from playing to paused. + If the tween has autoKill set to FALSE, this is called also when the tween reaches completion. + + + Sets the onRewind callback for the tween, clearing any previous onRewind callback that was set. + Called when the tween is rewinded, + either by calling Rewind or by reaching the start position while playing backwards. + Rewinding a tween that is already rewinded will not fire this callback + + + Sets the onUpdate callback for the tween, clearing any previous onUpdate callback that was set. + Called each time the tween updates + + + Sets the onStepComplete callback for the tween, clearing any previous onStepComplete callback that was set. + Called the moment the tween completes one loop cycle, even when going backwards + + + Sets the onComplete callback for the tween, clearing any previous onComplete callback that was set. + Called the moment the tween reaches its final forward position, loops included + + + Sets the onKill callback for the tween, clearing any previous onKill callback that was set. + Called the moment the tween is killed + + + Sets the onWaypointChange callback for the tween, clearing any previous onWaypointChange callback that was set. + Called when a path tween's current waypoint changes + + + Sets the parameters of the tween (id, ease, loops, delay, timeScale, callbacks, etc) as the parameters of the given one. + Doesn't copy specific SetOptions settings: those will need to be applied manually each time. + Has no effect if the tween has already started. + NOTE: the tween's target will not be changed + Tween from which to copy the parameters + + + Sets the parameters of the tween (id, ease, loops, delay, timeScale, callbacks, etc) as the parameters of the given TweenParams. + Has no effect if the tween has already started. + TweenParams from which to copy the parameters + + + Adds the given tween to the end of the Sequence. + Has no effect if the Sequence has already started + The tween to append + + + Adds the given tween to the beginning of the Sequence, pushing forward the other nested content. + Has no effect if the Sequence has already started + The tween to prepend + + + Inserts the given tween at the same time position of the last tween, callback or interval added to the Sequence. + Note that, in case of a Join after an interval, the insertion time will be the time where the interval starts, not where it finishes. + Has no effect if the Sequence has already started + + + Inserts the given tween at the given time position in the Sequence, + automatically adding an interval if needed. + Has no effect if the Sequence has already started + The time position where the tween will be placed + The tween to insert + + + Adds the given interval to the end of the Sequence. + Has no effect if the Sequence has already started + The interval duration + + + Adds the given interval to the beginning of the Sequence, pushing forward the other nested content. + Has no effect if the Sequence has already started + The interval duration + + + Adds the given callback to the end of the Sequence. + Has no effect if the Sequence has already started + The callback to append + + + Adds the given callback to the beginning of the Sequence, pushing forward the other nested content. + Has no effect if the Sequence has already started + The callback to prepend + + + Inserts the given callback at the same time position of the last tween, callback or interval added to the Sequence. + Note that, in case of a Join after an interval, the insertion time will be the time where the interval starts, not where it finishes. + Has no effect if the Sequence has already started + /// <param name="callback">The callback to prepend</param> + + + Inserts the given callback at the given time position in the Sequence, + automatically adding an interval if needed. + Has no effect if the Sequence has already started + The time position where the callback will be placed + The callback to insert + + + Changes a TO tween into a FROM tween: sets the current target's position as the tween's endValue + then immediately sends the target to the previously set endValue. + + + Changes a TO tween into a FROM tween: sets the current target's position as the tween's endValue + then immediately sends the target to the previously set endValue. + If TRUE the FROM value will be calculated as relative to the current one + + + Changes a TO tween into a FROM tween: sets the current value of the target as the endValue, + and the previously passed endValue as the actual startValue. + If TRUE sets the target to from value immediately, otherwise waits for the tween to start + If TRUE the FROM value will be calculated as relative to the current one + + + Changes a TO tween into a FROM tween: sets the tween's starting value to the given one + and eventually sets the tween's target to that value immediately. + Value to start from + If TRUE sets the target to from value immediately, otherwise waits for the tween to start + If TRUE the FROM/TO values will be calculated as relative to the current ones + + + Changes a TO tween into a FROM tween: sets the tween's starting value to the given one + and eventually sets the tween's target to that value immediately. + Alpha value to start from (in case of Fade tweens) + If TRUE sets the target to from value immediately, otherwise waits for the tween to start + If TRUE the FROM/TO values will be calculated as relative to the current ones + + + Changes a TO tween into a FROM tween: sets the tween's starting value to the given one + and eventually sets the tween's target to that value immediately. + Value to start from (in case of Vector tweens that act on a single coordinate or scale tweens) + If TRUE sets the target to from value immediately, otherwise waits for the tween to start + If TRUE the FROM/TO values will be calculated as relative to the current ones + + + Changes a TO tween into a FROM tween: sets the tween's starting value to the given one + and eventually sets the tween's target to that value immediately. + Value to start from (in case of Vector tweens that act on a single coordinate or scale tweens) + If TRUE sets the target to from value immediately, otherwise waits for the tween to start + If TRUE the FROM/TO values will be calculated as relative to the current ones + + + Sets a delayed startup for the tween. + In case of Sequences behaves the same as , + which means the delay will repeat in case of loops (while with tweens it's ignored after the first loop cycle). + Has no effect if the tween has already started + + + EXPERIMENTAL: implemented in v1.2.340. + Sets a delayed startup for the tween with options to choose how the delay is applied in case of Sequences. + Has no effect if the tween has already started + Only used by types: If FALSE sets the delay as a one-time occurrence + (defaults to this for types), + otherwise as a Sequence interval which will repeat at the beginning of every loop cycle + + + Sets the tween as relative + (the endValue will be calculated as startValue + endValue instead than being used directly). + Has no effect on Sequences or if the tween has already started + + + If isRelative is TRUE sets the tween as relative + (the endValue will be calculated as startValue + endValue instead than being used directly). + Has no effect on Sequences or if the tween has already started + + + If isSpeedBased is TRUE sets the tween as speed based + (the duration will represent the number of units the tween moves x second). + Has no effect on Sequences, nested tweens, or if the tween has already started + + + If isSpeedBased is TRUE sets the tween as speed based + (the duration will represent the number of units the tween moves x second). + Has no effect on Sequences, nested tweens, or if the tween has already started + + + Options for float tweens + If TRUE the tween will smoothly snap all values to integers + + + Options for Vector2 tweens + If TRUE the tween will smoothly snap all values to integers + + + Options for Vector2 tweens + Selecting an axis will tween the vector only on that axis, leaving the others untouched + If TRUE the tween will smoothly snap all values to integers + + + Options for Vector3 tweens + If TRUE the tween will smoothly snap all values to integers + + + Options for Vector3 tweens + Selecting an axis will tween the vector only on that axis, leaving the others untouched + If TRUE the tween will smoothly snap all values to integers + + + Options for Vector4 tweens + If TRUE the tween will smoothly snap all values to integers + + + Options for Vector4 tweens + Selecting an axis will tween the vector only on that axis, leaving the others untouched + If TRUE the tween will smoothly snap all values to integers + + + Options for Quaternion tweens + 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 + + + Options for Color tweens + If TRUE only the alpha value of the color will be tweened + + + Options for Vector4 tweens + If TRUE the tween will smoothly snap all values to integers + + + Options for Vector4 tweens + If TRUE, rich text will be interpreted correctly while animated, + otherwise all tags will be considered as normal text + The type of scramble to use, if any + A string containing the characters to use for scrambling. + Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters. + Leave it to NULL to use default ones + + + Options for Vector3Array tweens + If TRUE the tween will smoothly snap all values to integers + + + Options for Vector3Array tweens + If TRUE the tween will smoothly snap all values to integers + + + Options for ShapeCircle tweens + If TRUE the center you set in the DOTween.To method will be considered as relative + to the starting position of the target + If TRUE the tween will smoothly snap all values to integers + + + Options for Path tweens (created via the DOPath shortcut) + The eventual movement axis to lock. You can input multiple axis if you separate them like this: + AxisConstrain.X | AxisConstraint.Y + The eventual rotation axis to lock. You can input multiple axis if you separate them like this: + AxisConstrain.X | AxisConstraint.Y + + + Options for Path tweens (created via the DOPath shortcut) + If TRUE the path will be automatically closed + The eventual movement axis to lock. You can input multiple axis if you separate them like this: + AxisConstrain.X | AxisConstraint.Y + The eventual rotation axis to lock. You can input multiple axis if you separate them like this: + AxisConstrain.X | AxisConstraint.Y + + + Additional LookAt options for Path tweens (created via the DOPath shortcut). + Orients the target towards the given position. + Must be chained directly to the tween creation method or to a SetOptions + The position to look at + The eventual direction to consider as "forward". + If left to NULL defaults to the regular forward side of the transform + The vector that defines in which direction up is (default: Vector3.up) + + + Additional LookAt options for Path tweens (created via the DOPath shortcut). + Orients the target towards the given position with options to keep the Z rotation stable. + Must be chained directly to the tween creation method or to a SetOptions + The position to look at + If TRUE doesn't rotate the target along the Z axis + + + Additional LookAt options for Path tweens (created via the DOPath shortcut). + Orients the target towards another transform. + Must be chained directly to the tween creation method or to a SetOptions + The transform to look at + The eventual direction to consider as "forward". + If left to NULL defaults to the regular forward side of the transform + The vector that defines in which direction up is (default: Vector3.up) + + + Additional LookAt options for Path tweens (created via the DOPath shortcut). + Orients the target towards another transform with options to keep the Z rotation stable. + Must be chained directly to the tween creation method or to a SetOptions + The transform to look at + If TRUE doesn't rotate the target along the Z axis + + + Additional LookAt options for Path tweens (created via the DOPath shortcut). + Orients the target to the path, with the given lookAhead. + Must be chained directly to the tween creation method or to a SetOptions + The percentage of lookAhead to use (0 to 1) + The eventual direction to consider as "forward". + If left to NULL defaults to the regular forward side of the transform + The vector that defines in which direction up is (default: Vector3.up) + + + Additional LookAt options for Path tweens (created via the DOPath shortcut). + Orients the path with options to keep the Z rotation stable. + Must be chained directly to the tween creation method or to a SetOptions + The percentage of lookAhead to use (0 to 1) + If TRUE doesn't rotate the target along the Z axis + + + + Types of log behaviours + + + + Log only warnings and errors + + + Log warnings, errors and additional infos + + + Log only errors + + + + Indicates either a Tweener or a Sequence + + + + TimeScale for the tween + + + If TRUE the tween will play backwards + + + If TRUE the tween is completely inverted but without playing it backwards + (play backwards will actually play the tween in the original direction) + + + Object ID (usable for filtering with DOTween static methods). Can be anything except a string or an int + (use or for those) + + + String ID (usable for filtering with DOTween static methods). 2X faster than using an object id + + + Int ID (usable for filtering with DOTween static methods). 4X faster than using an object id, 2X faster than using a string id. + Default is -999 so avoid using an ID like that or it will capture all unset intIds + + + Tween target (usable for filtering with DOTween static methods). Automatically set by tween creation shortcuts + + + Called when the tween is set in a playing state, after any eventual delay. + Also called each time the tween resumes playing from a paused state + + + Called when the tween state changes from playing to paused. + If the tween has autoKill set to FALSE, this is called also when the tween reaches completion. + + + Called when the tween is rewinded, + either by calling Rewind or by reaching the start position while playing backwards. + Rewinding a tween that is already rewinded will not fire this callback + + + Called each time the tween updates + + + Called the moment the tween completes one loop cycle + + + Called the moment the tween reaches completion (loops included) + + + Called the moment the tween is killed + + + Called when a path tween's current waypoint changes + + + Tweeners-only (ignored by Sequences), returns TRUE if the tween was set as relative + + + + Set by SetTarget if DOTween's Debug Mode is on (see DOTween Utility Panel -> "Store GameObject's ID" debug option + + + + FALSE when tween is (or should be) despawned - set only by TweenManager + + + Gets and sets the time position (loops included, delays excluded) of the tween + + + Returns TRUE if the tween is set to loop (either a set number of times or infinitely) + + + TRUE after the tween was set in a play state at least once, AFTER any delay is elapsed + + + Time position within a single loop cycle + + + + Animates a single value + + + + Changes the start value of a tween and rewinds it (without pausing it). + Has no effect with tweens that are inside Sequences + The new start value + If bigger than 0 applies it as the new tween duration + + + Changes the end value of a tween and rewinds it (without pausing it). + Has no effect with tweens that are inside Sequences + The new end value + If bigger than 0 applies it as the new tween duration + If TRUE the start value will become the current target's value, otherwise it will stay the same + + + Changes the end value of a tween and rewinds it (without pausing it). + Has no effect with tweens that are inside Sequences + The new end value + If TRUE the start value will become the current target's value, otherwise it will stay the same + + + Changes the start and end value of a tween and rewinds it (without pausing it). + Has no effect with tweens that are inside Sequences + The new start value + The new end value + If bigger than 0 applies it as the new tween duration + + + + Used internally + + + + + Update type + + + + Updates every frame during Update calls + + + Updates every frame during LateUpdate calls + + + Updates using FixedUpdate calls + + + Updates using manual update calls + + + diff --git a/Assets/Plugins/Demigiant/DOTween/DOTween.XML.meta b/Assets/Plugins/Demigiant/DOTween/DOTween.XML.meta new file mode 100644 index 0000000..a22de5b --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/DOTween.XML.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 34192c5e0d14aee43a0e86cc4823268a +TextScriptImporter: + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/DOTween.XML + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/DOTween.dll b/Assets/Plugins/Demigiant/DOTween/DOTween.dll new file mode 100644 index 0000000000000000000000000000000000000000..1b0c4c7a4a42a5c379aa2713e2b524d867677a1c GIT binary patch literal 177664 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 De~$oG literal 0 HcmV?d00001 diff --git a/Assets/Plugins/Demigiant/DOTween/DOTween.dll.meta b/Assets/Plugins/Demigiant/DOTween/DOTween.dll.meta new file mode 100644 index 0000000..5a8ec09 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/DOTween.dll.meta @@ -0,0 +1,29 @@ +fileFormatVersion: 2 +guid: a811bde74b26b53498b4f6d872b09b6d +PluginImporter: + serializedVersion: 1 + iconMap: {} + executionOrder: {} + isPreloaded: 0 + platformData: + Any: + enabled: 1 + settings: {} + Editor: + enabled: 0 + settings: + DefaultValueInitialized: true + WindowsStoreApps: + enabled: 0 + settings: + CPU: AnyCPU + userData: + assetBundleName: + assetBundleVariant: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/DOTween.dll + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor.meta b/Assets/Plugins/Demigiant/DOTween/Editor.meta new file mode 100644 index 0000000..532edfb --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor.meta @@ -0,0 +1,5 @@ +fileFormatVersion: 2 +guid: b27f58ae5d5c33a4bb2d1f4f34bd036d +folderAsset: yes +DefaultImporter: + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML new file mode 100644 index 0000000..b893a67 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML @@ -0,0 +1,165 @@ + + + + DOTweenEditor + + + + + Contains compatibility methods taken from DemiEditor (for when DOTween is without it) + + + + + Warning: some versions of this method don't have the includeInactive parameter so it won't be taken into account + + + + + Warning: some versions of this method don't have the includeInactive parameter so it won't be taken into account + + + + + Warning: some versions of this method don't have the includeInactive parameter so it won't be taken into account + + + + + Warning: some versions of this method don't have the includeInactive parameter so it won't be taken into account + + + + + Starts the update loop of tween in the editor. Has no effect during playMode. + + Eventual callback to call after every update + + + + Stops the update loop and clears the onPreviewUpdated callback. + + If TRUE also resets the tweened objects to their original state. + Note that this works by calling Rewind on all tweens, so it will work correctly + only if you have a single tween type per object and it wasn't killed + If TRUE also kills any cached tween + + + + Readies the tween for editor preview by setting its UpdateType to Manual plus eventual extra settings. + + The tween to ready + If TRUE (recommended) removes all callbacks (OnComplete/Rewind/etc) + If TRUE prevents the tween from being auto-killed at completion + If TRUE starts playing the tween immediately + + + Full major version + first minor version (ex: 2018.1f) + + + Major version + + + First minor version (ex: in 2018.1 it would be 1) + + + + Checks that the given editor texture use the correct import settings, + and applies them if they're incorrect. + + + + + Returns TRUE if setup is required + + + + + Returns TRUE if the file/directory at the given path exists. + + Path, relative to Unity's project folder + + + + + Converts the given project-relative path to a full path, + with backward (\) slashes). + + + + + Converts the given full path to a path usable with AssetDatabase methods + (relative to Unity's project folder, and with the correct Unity forward (/) slashes). + + + + + Connects to a asset. + If the asset already exists at the given path, loads it and returns it. + Otherwise, either returns NULL or automatically creates it before loading and returning it + (depending on the given parameters). + + Asset type + File path (relative to Unity's project folder) + If TRUE and the requested asset doesn't exist, forces its creation + + + + Full path for the given loaded assembly, assembly file included + + + + + Adds the given global define if it's not already present + + + + + Removes the given global define if it's present + + + + + Returns TRUE if the given global define is present in all the + or only in the given , depending on passed parameters. + + + to use. Leave NULL to check in all of them. + + + + Not used as menu item anymore, but as a utility function + + + + Sets the modules bool values to the current defines state + + + Refreshes the enabled state of all defines + + + Applies the guiEnabled value state to each define, adding or removing them based on that + + + Removes all DOTween defines including the ones for external assets + + + Removes all legacy defines + + + Removes the define if present + + + Adds the define if it's not already present + + + Full major version + first minor version (ex: 2018.1f) + + + Major version + + + First minor version (ex: in 2018.1 it would be 1) + + + diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML.meta b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML.meta new file mode 100644 index 0000000..d13332c --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2e2c6224d345d9249acfa6e8ef40bb2d +TextScriptImporter: + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll new file mode 100644 index 0000000000000000000000000000000000000000..8cec399b07ff1a8644680bc0630bf4060ac970c6 GIT binary patch literal 66560 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 literal 0 HcmV?d00001 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll.meta b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll.meta new file mode 100644 index 0000000..8f38199 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll.meta @@ -0,0 +1,29 @@ +fileFormatVersion: 2 +guid: 45d5034162d6cf04dbe46da84fc7d074 +PluginImporter: + serializedVersion: 1 + iconMap: {} + executionOrder: {} + isPreloaded: 0 + platformData: + Any: + enabled: 0 + settings: {} + Editor: + enabled: 1 + settings: + DefaultValueInitialized: true + WindowsStoreApps: + enabled: 0 + settings: + CPU: AnyCPU + userData: + assetBundleName: + assetBundleVariant: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.XML b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.XML new file mode 100644 index 0000000..02c3c95 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.XML @@ -0,0 +1,14 @@ + + + + DOTweenUpgradeManager + + + + + This class and its whole library are deleted the first time DOTween's setup is run after an upgrade (or after a new install). + NOTE: DidReloadScripts doesn't work on first install so it's useless, InitializeOnLoad is the only way + + + + diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.XML.meta b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.XML.meta new file mode 100644 index 0000000..f37f6be --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.XML.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3df9fdaadcb4c394e826a4d8d20bb952 +TextScriptImporter: + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.XML + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.dll b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.dll new file mode 100644 index 0000000000000000000000000000000000000000..d8c36d8004beca623e72294a6a2b1c935181edb0 GIT binary patch literal 11264 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 literal 0 HcmV?d00001 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.dll.meta b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.dll.meta new file mode 100644 index 0000000..7b3b063 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.dll.meta @@ -0,0 +1,29 @@ +fileFormatVersion: 2 +guid: 2bf936a5d80799e4e88ec9270fea75a4 +PluginImporter: + serializedVersion: 1 + iconMap: {} + executionOrder: {} + isPreloaded: 0 + platformData: + Any: + enabled: 0 + settings: {} + Editor: + enabled: 1 + settings: + DefaultValueInitialized: true + WindowsStoreApps: + enabled: 0 + settings: + CPU: AnyCPU + userData: + assetBundleName: + assetBundleVariant: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.dll + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/Imgs.meta b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs.meta new file mode 100644 index 0000000..a81ba5f --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs.meta @@ -0,0 +1,5 @@ +fileFormatVersion: 2 +guid: 0034ebae0c2a9344e897db1160d71b6d +folderAsset: yes +DefaultImporter: + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..d06fc7c3e49fb705b19f50a23884e11e08fd6e89 GIT binary patch literal 1565 zcmV+&2IBdNP)pK&q+iZU-R{R_dCD)yXSsA=iKiWUaHS%xglyYZad)#h+<5;*}0 zNm4;#XNMU$Zj;|vsJ23aE-5O{$8uo1iN`?c(v%ev86gvrQJJtDUgxox^bsB@>w%Sv@Z{F3?7c1><;yj*g<&fQ;rHj}CCd5!B9uJ9iB}?8sX9 z0l}mbA`+6NSzvKr7orW|#Qq*|(_H8{K}SN-b6PMMr68BfK|728UnV4rbuENZG2Z=Z5Wu9k@Z ztFhSr_^u&Go2vR`!G?lmnDf^U%@^vc&8BfCWA&5;S^i0KcuQ?}kJ(Z3^ukf69xF;y zhTjIduJg}*jhXlo$g+|CIjkSftK3odtF^Ij{rKV$Cnn9$)I>`OWpR2BZvMLfc!?KG z`Ygj57^xT!Rkoeb;;a>--p1*pKcW45EApC=r9;lR-6-kL1bPPs&3JrJ`3>IVgWG}u zrp-R@PdWz2X;89OBJXFclQSuKH%hu+=km#Rb8S^yF>)=)yvW|npJ`O9bTXp9hsHlb znp{n43g)Eywa^bS0=L=}#fV_6`pc{T=00UOIql`_gv<&0h%GG1sFbh_*L zqP^;2G6HL$uEjx);7q^Pe;Vac1Sb6of8vi>KZaIU-M!xHLy7h)J?TTTtlXuy)v(S-r9V9I7cw) zBJ@dWbWCbJy!KBwxl~8X#1q??E z(FRaBcRnf^OG3xEWE{XiDJhYPVBV54Q*B2`fK%)r4bJp zv@(2PX=l*%^bG!@&}Ku`gi%4ta5WNM0#2BfuE7?N_gS0ljFV#0yW1U1N=~9Q$*7V9 zs*5|&bg|QQt;WLQDrER5jfAhm2W6wJag5au!96_|(2Th-DB`E<_rUdkM#GW4COG!3 z`K~-?KL;C^l|r|5RUE^pEPvtTLR^K!B04D#hpLNGOCz;*Z|Rx&7b{!rLVU{NI)eH5 zyg0@a6A$elUi>gA6@P$cWD53gSzVnTr*}j6sd4;47Sd19E6U{>QXP%UxLJ2^hjTS@ z6ZIq2+r)$@>IAiS(jN5U4r-m;p98e&wn5+}NTri*S7~M1@c0mh@Mz$FrSMzj$u5?< P00000NkvXXu0mjftl$Bl literal 0 HcmV?d00001 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png.meta b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png.meta new file mode 100644 index 0000000..bf56266 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png.meta @@ -0,0 +1,54 @@ +fileFormatVersion: 2 +guid: 8da095e39e9b4df488dfd436f81116d6 +TextureImporter: + fileIDToRecycleName: {} + serializedVersion: 2 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + linearTexture: 1 + correctGamma: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: .25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 0 + seamlessCubemap: 0 + textureFormat: -3 + maxTextureSize: 128 + textureSettings: + filterMode: 1 + aniso: 1 + mipBias: -1 + wrapMode: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: .5, y: .5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaIsTransparency: 1 + textureType: 2 + buildTargetSettings: [] + spriteSheet: + sprites: [] + spritePackingTag: + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenMiniIcon.png b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenMiniIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..7cd74c1a26df1a45564c7a0e21c62d0ef3af2fd1 GIT binary patch literal 319 zcmeAS@N?(olHy`uVBq!ia0vp^oFL4>1|%O$WD@{!3Opi<85sBugD~Uq{1quc!H=FU zjv*3LlT#WP(iF^Cl2R3(u|Mi}s1fft&-^joZ3WZ(2Ug1Y!S$8-a*li}_21XqSnvJ# z@Y+`2=i8W`Zfg*cV81TuZmqUr`JI~8M}9x(m1v%HMLo`ySuokJ?%Vq7{C4$+ST-HH z5`RuO<@s#=8XoVy+lF)YEaxg?4vAr1(jlM1>Tx0PF<0}pFUf679a{7Ee==}5`qQz? zuIUa#(3byge21?t-^6oqTDwHc&iz0s`zDdQwtGKbESsPtIM1KwqFB4+nW=frYn!|7 zvs(U9y->(A=TFZ3t)>6Hv^;B{u+A(fd3smW;eIaTDS0KOITHVv7#gf%Y$mkMJ`MCd NgQu&X%Q~loCICTRfS>>X literal 0 HcmV?d00001 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenMiniIcon.png.meta b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenMiniIcon.png.meta new file mode 100644 index 0000000..7144a25 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenMiniIcon.png.meta @@ -0,0 +1,75 @@ +fileFormatVersion: 2 +guid: 61521df2e071645488ba3d05e49289ae +timeCreated: 1602317874 +licenseType: Store +TextureImporter: + fileIDToRecycleName: {} + serializedVersion: 4 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + filterMode: -1 + aniso: -1 + mipBias: -1 + wrapMode: -1 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + spritePackingTag: + userData: + assetBundleName: + assetBundleVariant: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenMiniIcon.png + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png new file mode 100644 index 0000000000000000000000000000000000000000..e29d02fe18b777b1d316feb647b339803c5126de GIT binary patch literal 4409 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 literal 0 HcmV?d00001 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png.meta b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png.meta new file mode 100644 index 0000000..0c5a1c5 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png.meta @@ -0,0 +1,54 @@ +fileFormatVersion: 2 +guid: 7051dba417b3d53409f2918f1ea4938d +TextureImporter: + fileIDToRecycleName: {} + serializedVersion: 2 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + linearTexture: 1 + correctGamma: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: .25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 0 + seamlessCubemap: 0 + textureFormat: -3 + maxTextureSize: 256 + textureSettings: + filterMode: 1 + aniso: 1 + mipBias: -1 + wrapMode: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: .5, y: .5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaIsTransparency: 1 + textureType: 2 + buildTargetSettings: [] + spriteSheet: + sprites: [] + spritePackingTag: + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png new file mode 100644 index 0000000000000000000000000000000000000000..e48db5ef7a2b83eff50d6e3b5fe9ba3bcd4a5015 GIT binary patch literal 4429 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 TqmFO~00000NkvXXu0mjf{EM6C literal 0 HcmV?d00001 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png.meta b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png.meta new file mode 100644 index 0000000..54cff49 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png.meta @@ -0,0 +1,54 @@ +fileFormatVersion: 2 +guid: 519694efe2bb2914788b151fbd8c01f4 +TextureImporter: + fileIDToRecycleName: {} + serializedVersion: 2 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + linearTexture: 0 + correctGamma: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: .25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 0 + seamlessCubemap: 0 + textureFormat: -1 + maxTextureSize: 1024 + textureSettings: + filterMode: -1 + aniso: -1 + mipBias: -1 + wrapMode: -1 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: .5, y: .5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaIsTransparency: 0 + textureType: -1 + buildTargetSettings: [] + spriteSheet: + sprites: [] + spritePackingTag: + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4d710d719075150879b1ee76680af87791c4d3b3 GIT binary patch literal 22787 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 QE#Li`lK-oJv9mh=KQ4fgsQ>@~ literal 0 HcmV?d00001 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg.meta b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg.meta new file mode 100644 index 0000000..1d89975 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg.meta @@ -0,0 +1,54 @@ +fileFormatVersion: 2 +guid: 78a59ca99f8987941adb61f9e14a06a7 +TextureImporter: + fileIDToRecycleName: {} + serializedVersion: 2 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + linearTexture: 1 + correctGamma: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: .25 + normalMapFilter: 0 + isReadable: 0 + grayScaleToAlpha: 0 + generateCubemap: 0 + seamlessCubemap: 0 + textureFormat: -3 + maxTextureSize: 512 + textureSettings: + filterMode: 1 + aniso: 1 + mipBias: -1 + wrapMode: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: .5, y: .5} + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spritePixelsToUnits: 100 + alphaIsTransparency: 1 + textureType: 2 + buildTargetSettings: [] + spriteSheet: + sprites: [] + spritePackingTag: + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules.meta b/Assets/Plugins/Demigiant/DOTween/Modules.meta new file mode 100644 index 0000000..24cd2ac --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules.meta @@ -0,0 +1,5 @@ +fileFormatVersion: 2 +guid: 143604b8bad857d47a6f7cc7a533e2dc +folderAsset: yes +DefaultImporter: + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs new file mode 100644 index 0000000..ada1879 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs @@ -0,0 +1,198 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +#if !DOTWEEN_NOAUDIO // MODULE_MARKER +using System; +using DG.Tweening.Core; +using DG.Tweening.Plugins.Options; +using UnityEngine; +using UnityEngine.Audio; // Required for AudioMixer + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModuleAudio + { + #region Shortcuts + + #region Audio + + /// Tweens an AudioSource's volume to the given value. + /// Also stores the AudioSource as the tween's target so it can be used for filtered operations + /// The end value to reach (0 to 1)The duration of the tween + public static TweenerCore DOFade(this AudioSource target, float endValue, float duration) + { + if (endValue < 0) endValue = 0; + else if (endValue > 1) endValue = 1; + TweenerCore t = DOTween.To(() => target.volume, x => target.volume = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens an AudioSource's pitch to the given value. + /// Also stores the AudioSource as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOPitch(this AudioSource target, float endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.pitch, x => target.pitch = x, endValue, duration); + t.SetTarget(target); + return t; + } + + #endregion + + #region AudioMixer + + /// Tweens an AudioMixer's exposed float to the given value. + /// Also stores the AudioMixer as the tween's target so it can be used for filtered operations. + /// Note that you need to manually expose a float in an AudioMixerGroup in order to be able to tween it from an AudioMixer. + /// Name given to the exposed float to set + /// The end value to reachThe duration of the tween + public static TweenerCore DOSetFloat(this AudioMixer target, string floatName, float endValue, float duration) + { + TweenerCore t = DOTween.To(()=> { + float currVal; + target.GetFloat(floatName, out currVal); + return currVal; + }, x=> target.SetFloat(floatName, x), endValue, duration); + t.SetTarget(target); + return t; + } + + #region Operation Shortcuts + + /// + /// Completes all tweens that have this target as a reference + /// (meaning tweens that were started from this target, or that had this target added as an Id) + /// and returns the total number of tweens completed + /// (meaning the tweens that don't have infinite loops and were not already complete) + /// + /// For Sequences only: if TRUE also internal Sequence callbacks will be fired, + /// otherwise they will be ignored + public static int DOComplete(this AudioMixer target, bool withCallbacks = false) + { + return DOTween.Complete(target, withCallbacks); + } + + /// + /// Kills all tweens that have this target as a reference + /// (meaning tweens that were started from this target, or that had this target added as an Id) + /// and returns the total number of tweens killed. + /// + /// If TRUE completes the tween before killing it + public static int DOKill(this AudioMixer target, bool complete = false) + { + return DOTween.Kill(target, complete); + } + + /// + /// Flips the direction (backwards if it was going forward or viceversa) of all tweens that have this target as a reference + /// (meaning tweens that were started from this target, or that had this target added as an Id) + /// and returns the total number of tweens flipped. + /// + public static int DOFlip(this AudioMixer target) + { + return DOTween.Flip(target); + } + + /// + /// Sends to the given position all tweens that have this target as a reference + /// (meaning tweens that were started from this target, or that had this target added as an Id) + /// and returns the total number of tweens involved. + /// + /// Time position to reach + /// (if higher than the whole tween duration the tween will simply reach its end) + /// If TRUE will play the tween after reaching the given position, otherwise it will pause it + public static int DOGoto(this AudioMixer target, float to, bool andPlay = false) + { + return DOTween.Goto(target, to, andPlay); + } + + /// + /// Pauses all tweens that have this target as a reference + /// (meaning tweens that were started from this target, or that had this target added as an Id) + /// and returns the total number of tweens paused. + /// + public static int DOPause(this AudioMixer target) + { + return DOTween.Pause(target); + } + + /// + /// Plays all tweens that have this target as a reference + /// (meaning tweens that were started from this target, or that had this target added as an Id) + /// and returns the total number of tweens played. + /// + public static int DOPlay(this AudioMixer target) + { + return DOTween.Play(target); + } + + /// + /// Plays backwards all tweens that have this target as a reference + /// (meaning tweens that were started from this target, or that had this target added as an Id) + /// and returns the total number of tweens played. + /// + public static int DOPlayBackwards(this AudioMixer target) + { + return DOTween.PlayBackwards(target); + } + + /// + /// Plays forward all tweens that have this target as a reference + /// (meaning tweens that were started from this target, or that had this target added as an Id) + /// and returns the total number of tweens played. + /// + public static int DOPlayForward(this AudioMixer target) + { + return DOTween.PlayForward(target); + } + + /// + /// Restarts all tweens that have this target as a reference + /// (meaning tweens that were started from this target, or that had this target added as an Id) + /// and returns the total number of tweens restarted. + /// + public static int DORestart(this AudioMixer target) + { + return DOTween.Restart(target); + } + + /// + /// Rewinds all tweens that have this target as a reference + /// (meaning tweens that were started from this target, or that had this target added as an Id) + /// and returns the total number of tweens rewinded. + /// + public static int DORewind(this AudioMixer target) + { + return DOTween.Rewind(target); + } + + /// + /// Smoothly rewinds all tweens that have this target as a reference + /// (meaning tweens that were started from this target, or that had this target added as an Id) + /// and returns the total number of tweens rewinded. + /// + public static int DOSmoothRewind(this AudioMixer target) + { + return DOTween.SmoothRewind(target); + } + + /// + /// Toggles the paused state (plays if it was paused, pauses if it was playing) of all tweens that have this target as a reference + /// (meaning tweens that were started from this target, or that had this target added as an Id) + /// and returns the total number of tweens involved. + /// + public static int DOTogglePause(this AudioMixer target) + { + return DOTween.TogglePause(target); + } + + #endregion + + #endregion + + #endregion + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs.meta new file mode 100644 index 0000000..6892c62 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs.meta @@ -0,0 +1,15 @@ +fileFormatVersion: 2 +guid: b766d08851589514b97afb23c6f30a70 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs new file mode 100644 index 0000000..4eb7b77 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs @@ -0,0 +1,146 @@ +using UnityEngine; + +#if DOTWEEN_EPO || EPO_DOTWEEN // MODULE_MARKER + +using EPOOutline; +using DG.Tweening.Plugins.Options; +using DG.Tweening; +using DG.Tweening.Core; + +namespace DG.Tweening +{ + public static class DOTweenModuleEPOOutline + { + public static int DOKill(this SerializedPass target, bool complete) + { + return DOTween.Kill(target, complete); + } + + public static TweenerCore DOFloat(this SerializedPass target, string propertyName, float endValue, float duration) + { + var tweener = DOTween.To(() => target.GetFloat(propertyName), x => target.SetFloat(propertyName, x), endValue, duration); + tweener.SetOptions(true).SetTarget(target); + return tweener; + } + + public static TweenerCore DOFade(this SerializedPass target, string propertyName, float endValue, float duration) + { + var tweener = DOTween.ToAlpha(() => target.GetColor(propertyName), x => target.SetColor(propertyName, x), endValue, duration); + tweener.SetOptions(true).SetTarget(target); + return tweener; + } + + public static TweenerCore DOColor(this SerializedPass target, string propertyName, Color endValue, float duration) + { + var tweener = DOTween.To(() => target.GetColor(propertyName), x => target.SetColor(propertyName, x), endValue, duration); + tweener.SetOptions(false).SetTarget(target); + return tweener; + } + + public static TweenerCore DOVector(this SerializedPass target, string propertyName, Vector4 endValue, float duration) + { + var tweener = DOTween.To(() => target.GetVector(propertyName), x => target.SetVector(propertyName, x), endValue, duration); + tweener.SetOptions(false).SetTarget(target); + return tweener; + } + + public static TweenerCore DOFloat(this SerializedPass target, int propertyId, float endValue, float duration) + { + var tweener = DOTween.To(() => target.GetFloat(propertyId), x => target.SetFloat(propertyId, x), endValue, duration); + tweener.SetOptions(true).SetTarget(target); + return tweener; + } + + public static TweenerCore DOFade(this SerializedPass target, int propertyId, float endValue, float duration) + { + var tweener = DOTween.ToAlpha(() => target.GetColor(propertyId), x => target.SetColor(propertyId, x), endValue, duration); + tweener.SetOptions(true).SetTarget(target); + return tweener; + } + + public static TweenerCore DOColor(this SerializedPass target, int propertyId, Color endValue, float duration) + { + var tweener = DOTween.To(() => target.GetColor(propertyId), x => target.SetColor(propertyId, x), endValue, duration); + tweener.SetOptions(false).SetTarget(target); + return tweener; + } + + public static TweenerCore DOVector(this SerializedPass target, int propertyId, Vector4 endValue, float duration) + { + var tweener = DOTween.To(() => target.GetVector(propertyId), x => target.SetVector(propertyId, x), endValue, duration); + tweener.SetOptions(false).SetTarget(target); + return tweener; + } + + public static int DOKill(this Outlinable.OutlineProperties target, bool complete = false) + { + return DOTween.Kill(target, complete); + } + + public static int DOKill(this Outliner target, bool complete = false) + { + return DOTween.Kill(target, complete); + } + + /// + /// Controls the alpha (transparency) of the outline + /// + public static TweenerCore DOFade(this Outlinable.OutlineProperties target, float endValue, float duration) + { + var tweener = DOTween.ToAlpha(() => target.Color, x => target.Color = x, endValue, duration); + tweener.SetOptions(true).SetTarget(target); + return tweener; + } + + /// + /// Controls the color of the outline + /// + public static TweenerCore DOColor(this Outlinable.OutlineProperties target, Color endValue, float duration) + { + var tweener = DOTween.To(() => target.Color, x => target.Color = x, endValue, duration); + tweener.SetOptions(false).SetTarget(target); + return tweener; + } + + /// + /// Controls the amount of blur applied to the outline + /// + public static TweenerCore DOBlurShift(this Outlinable.OutlineProperties target, float endValue, float duration, bool snapping = false) + { + var tweener = DOTween.To(() => target.BlurShift, x => target.BlurShift = x, endValue, duration); + tweener.SetOptions(snapping).SetTarget(target); + return tweener; + } + + /// + /// Controls the amount of blur applied to the outline + /// + public static TweenerCore DOBlurShift(this Outliner target, float endValue, float duration, bool snapping = false) + { + var tweener = DOTween.To(() => target.BlurShift, x => target.BlurShift = x, endValue, duration); + tweener.SetOptions(snapping).SetTarget(target); + return tweener; + } + + /// + /// Controls the amount of dilation applied to the outline + /// + public static TweenerCore DODilateShift(this Outlinable.OutlineProperties target, float endValue, float duration, bool snapping = false) + { + var tweener = DOTween.To(() => target.DilateShift, x => target.DilateShift = x, endValue, duration); + tweener.SetOptions(snapping).SetTarget(target); + return tweener; + } + + /// + /// Controls the amount of dilation applied to the outline + /// + public static TweenerCore DODilateShift(this Outliner target, float endValue, float duration, bool snapping = false) + { + var tweener = DOTween.To(() => target.DilateShift, x => target.DilateShift = x, endValue, duration); + tweener.SetOptions(snapping).SetTarget(target); + return tweener; + } + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs.meta new file mode 100644 index 0000000..63900da --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs.meta @@ -0,0 +1,19 @@ +fileFormatVersion: 2 +guid: e944529dcaee98f4e9498d80e541d93e +timeCreated: 1602593330 +licenseType: Store +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs new file mode 100644 index 0000000..51786e3 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs @@ -0,0 +1,216 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +#if !DOTWEEN_NOPHYSICS // MODULE_MARKER +using System; +using DG.Tweening.Core; +using DG.Tweening.Core.Enums; +using DG.Tweening.Plugins; +using DG.Tweening.Plugins.Core.PathCore; +using DG.Tweening.Plugins.Options; +using UnityEngine; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModulePhysics + { + #region Shortcuts + + #region Rigidbody + + /// Tweens a Rigidbody's position to the given value. + /// Also stores the rigidbody as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMove(this Rigidbody target, Vector3 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody's X position to the given value. + /// Also stores the rigidbody as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveX(this Rigidbody target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue, 0, 0), duration); + t.SetOptions(AxisConstraint.X, snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody's Y position to the given value. + /// Also stores the rigidbody as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveY(this Rigidbody target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, endValue, 0), duration); + t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody's Z position to the given value. + /// Also stores the rigidbody as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveZ(this Rigidbody target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, 0, endValue), duration); + t.SetOptions(AxisConstraint.Z, snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody's rotation to the given value. + /// Also stores the rigidbody as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// Rotation mode + public static TweenerCore DORotate(this Rigidbody target, Vector3 endValue, float duration, RotateMode mode = RotateMode.Fast) + { + TweenerCore t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration); + t.SetTarget(target); + t.plugOptions.rotateMode = mode; + return t; + } + + /// Tweens a Rigidbody's rotation so that it will look towards the given position. + /// Also stores the rigidbody as the tween's target so it can be used for filtered operations + /// The position to look atThe duration of the tween + /// Eventual axis constraint for the rotation + /// The vector that defines in which direction up is (default: Vector3.up) + public static TweenerCore DOLookAt(this Rigidbody target, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3? up = null) + { + TweenerCore t = DOTween.To(() => target.rotation, target.MoveRotation, towards, duration) + .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetLookAt); + t.plugOptions.axisConstraint = axisConstraint; + t.plugOptions.up = (up == null) ? Vector3.up : (Vector3)up; + return t; + } + + #region Special + + /// Tweens a Rigidbody's position to the given value, while also applying a jump effect along the Y axis. + /// Returns a Sequence instead of a Tweener. + /// Also stores the Rigidbody as the tween's target so it can be used for filtered operations + /// The end value to reach + /// Power of the jump (the max height of the jump is represented by this plus the final Y offset) + /// Total number of jumps + /// The duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static Sequence DOJump(this Rigidbody target, Vector3 endValue, float jumpPower, int numJumps, float duration, bool snapping = false) + { + if (numJumps < 1) numJumps = 1; + float startPosY = 0; + float offsetY = -1; + bool offsetYSet = false; + Sequence s = DOTween.Sequence(); + Tween yTween = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, jumpPower, 0), duration / (numJumps * 2)) + .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative() + .SetLoops(numJumps * 2, LoopType.Yoyo) + .OnStart(() => startPosY = target.position.y); + s.Append(DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue.x, 0, 0), duration) + .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear) + ).Join(DOTween.To(() => target.position, target.MovePosition, new Vector3(0, 0, endValue.z), duration) + .SetOptions(AxisConstraint.Z, snapping).SetEase(Ease.Linear) + ).Join(yTween) + .SetTarget(target).SetEase(DOTween.defaultEaseType); + yTween.OnUpdate(() => { + if (!offsetYSet) { + offsetYSet = true; + offsetY = s.isRelative ? endValue.y : endValue.y - startPosY; + } + Vector3 pos = target.position; + pos.y += DOVirtual.EasedValue(0, offsetY, yTween.ElapsedPercentage(), Ease.OutQuad); + target.MovePosition(pos); + }); + return s; + } + + /// Tweens a Rigidbody's position through the given path waypoints, using the chosen path algorithm. + /// Also stores the Rigidbody as the tween's target so it can be used for filtered operations. + /// NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened. + /// BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug). + /// If you plan to publish there you should use a regular transform.DOPath. + /// The waypoints to go through + /// The duration of the tween + /// The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points) + /// The path mode: 3D, side-scroller 2D, top-down 2D + /// The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved paths but are more expensive. + /// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints + /// The color of the path (shown when gizmos are active in the Play panel and the tween is running) + public static TweenerCore DOPath( + this Rigidbody target, Vector3[] path, float duration, PathType pathType = PathType.Linear, + PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null + ) + { + if (resolution < 1) resolution = 1; + TweenerCore t = DOTween.To(PathPlugin.Get(), () => target.position, target.MovePosition, new Path(pathType, path, resolution, gizmoColor), duration) + .SetTarget(target).SetUpdate(UpdateType.Fixed); + + t.plugOptions.isRigidbody = true; + t.plugOptions.mode = pathMode; + return t; + } + /// Tweens a Rigidbody's localPosition through the given path waypoints, using the chosen path algorithm. + /// Also stores the Rigidbody as the tween's target so it can be used for filtered operations + /// NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened. + /// BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug). + /// If you plan to publish there you should use a regular transform.DOLocalPath. + /// The waypoint to go through + /// The duration of the tween + /// The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points) + /// The path mode: 3D, side-scroller 2D, top-down 2D + /// The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive. + /// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints + /// The color of the path (shown when gizmos are active in the Play panel and the tween is running) + public static TweenerCore DOLocalPath( + this Rigidbody target, Vector3[] path, float duration, PathType pathType = PathType.Linear, + PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null + ) + { + if (resolution < 1) resolution = 1; + Transform trans = target.transform; + TweenerCore t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), new Path(pathType, path, resolution, gizmoColor), duration) + .SetTarget(target).SetUpdate(UpdateType.Fixed); + + t.plugOptions.isRigidbody = true; + t.plugOptions.mode = pathMode; + t.plugOptions.useLocalPosition = true; + return t; + } + // Used by path editor when creating the actual tween, so it can pass a pre-compiled path + internal static TweenerCore DOPath( + this Rigidbody target, Path path, float duration, PathMode pathMode = PathMode.Full3D + ) + { + TweenerCore t = DOTween.To(PathPlugin.Get(), () => target.position, target.MovePosition, path, duration) + .SetTarget(target); + + t.plugOptions.isRigidbody = true; + t.plugOptions.mode = pathMode; + return t; + } + internal static TweenerCore DOLocalPath( + this Rigidbody target, Path path, float duration, PathMode pathMode = PathMode.Full3D + ) + { + Transform trans = target.transform; + TweenerCore t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), path, duration) + .SetTarget(target); + + t.plugOptions.isRigidbody = true; + t.plugOptions.mode = pathMode; + t.plugOptions.useLocalPosition = true; + return t; + } + + #endregion + + #endregion + + #endregion + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs.meta new file mode 100644 index 0000000..e172e98 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs.meta @@ -0,0 +1,15 @@ +fileFormatVersion: 2 +guid: dae9aa560b4242648a3affa2bfabc365 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs new file mode 100644 index 0000000..045eccc --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs @@ -0,0 +1,193 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +#if !DOTWEEN_NOPHYSICS2D // MODULE_MARKER +using System; +using DG.Tweening.Core; +using DG.Tweening.Plugins; +using DG.Tweening.Plugins.Core.PathCore; +using DG.Tweening.Plugins.Options; +using UnityEngine; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModulePhysics2D + { + #region Shortcuts + + #region Rigidbody2D Shortcuts + + /// Tweens a Rigidbody2D's position to the given value. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMove(this Rigidbody2D target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody2D's X position to the given value. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveX(this Rigidbody2D target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, new Vector2(endValue, 0), duration); + t.SetOptions(AxisConstraint.X, snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody2D's Y position to the given value. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveY(this Rigidbody2D target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, new Vector2(0, endValue), duration); + t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody2D's rotation to the given value. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DORotate(this Rigidbody2D target, float endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration); + t.SetTarget(target); + return t; + } + + #region Special + + /// Tweens a Rigidbody2D's position to the given value, while also applying a jump effect along the Y axis. + /// Returns a Sequence instead of a Tweener. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations. + /// IMPORTANT: a rigidbody2D can't be animated in a jump arc using MovePosition, so the tween will directly set the position + /// The end value to reach + /// Power of the jump (the max height of the jump is represented by this plus the final Y offset) + /// Total number of jumps + /// The duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static Sequence DOJump(this Rigidbody2D target, Vector2 endValue, float jumpPower, int numJumps, float duration, bool snapping = false) + { + if (numJumps < 1) numJumps = 1; + float startPosY = 0; + float offsetY = -1; + bool offsetYSet = false; + Sequence s = DOTween.Sequence(); + Tween yTween = DOTween.To(() => target.position, x => target.position = x, new Vector2(0, jumpPower), duration / (numJumps * 2)) + .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative() + .SetLoops(numJumps * 2, LoopType.Yoyo) + .OnStart(() => startPosY = target.position.y); + s.Append(DOTween.To(() => target.position, x => target.position = x, new Vector2(endValue.x, 0), duration) + .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear) + ).Join(yTween) + .SetTarget(target).SetEase(DOTween.defaultEaseType); + yTween.OnUpdate(() => { + if (!offsetYSet) { + offsetYSet = true; + offsetY = s.isRelative ? endValue.y : endValue.y - startPosY; + } + Vector3 pos = target.position; + pos.y += DOVirtual.EasedValue(0, offsetY, yTween.ElapsedPercentage(), Ease.OutQuad); + target.MovePosition(pos); + }); + return s; + } + + /// Tweens a Rigidbody2D's position through the given path waypoints, using the chosen path algorithm. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations. + /// NOTE: to tween a Rigidbody2D correctly it should be set to kinematic at least while being tweened. + /// BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug). + /// If you plan to publish there you should use a regular transform.DOPath. + /// The waypoints to go through + /// The duration of the tween + /// The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points) + /// The path mode: 3D, side-scroller 2D, top-down 2D + /// The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved paths but are more expensive. + /// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints + /// The color of the path (shown when gizmos are active in the Play panel and the tween is running) + public static TweenerCore DOPath( + this Rigidbody2D target, Vector2[] path, float duration, PathType pathType = PathType.Linear, + PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null + ) + { + if (resolution < 1) resolution = 1; + int len = path.Length; + Vector3[] path3D = new Vector3[len]; + for (int i = 0; i < len; ++i) path3D[i] = path[i]; + TweenerCore t = DOTween.To(PathPlugin.Get(), () => target.position, x => target.MovePosition(x), new Path(pathType, path3D, resolution, gizmoColor), duration) + .SetTarget(target).SetUpdate(UpdateType.Fixed); + + t.plugOptions.isRigidbody2D = true; + t.plugOptions.mode = pathMode; + return t; + } + /// Tweens a Rigidbody2D's localPosition through the given path waypoints, using the chosen path algorithm. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations + /// NOTE: to tween a Rigidbody2D correctly it should be set to kinematic at least while being tweened. + /// BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug). + /// If you plan to publish there you should use a regular transform.DOLocalPath. + /// The waypoint to go through + /// The duration of the tween + /// The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points) + /// The path mode: 3D, side-scroller 2D, top-down 2D + /// The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive. + /// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints + /// The color of the path (shown when gizmos are active in the Play panel and the tween is running) + public static TweenerCore DOLocalPath( + this Rigidbody2D target, Vector2[] path, float duration, PathType pathType = PathType.Linear, + PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null + ) + { + if (resolution < 1) resolution = 1; + int len = path.Length; + Vector3[] path3D = new Vector3[len]; + for (int i = 0; i < len; ++i) path3D[i] = path[i]; + Transform trans = target.transform; + TweenerCore t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), new Path(pathType, path3D, resolution, gizmoColor), duration) + .SetTarget(target).SetUpdate(UpdateType.Fixed); + + t.plugOptions.isRigidbody2D = true; + t.plugOptions.mode = pathMode; + t.plugOptions.useLocalPosition = true; + return t; + } + // Used by path editor when creating the actual tween, so it can pass a pre-compiled path + internal static TweenerCore DOPath( + this Rigidbody2D target, Path path, float duration, PathMode pathMode = PathMode.Full3D + ) + { + TweenerCore t = DOTween.To(PathPlugin.Get(), () => target.position, x => target.MovePosition(x), path, duration) + .SetTarget(target); + + t.plugOptions.isRigidbody2D = true; + t.plugOptions.mode = pathMode; + return t; + } + internal static TweenerCore DOLocalPath( + this Rigidbody2D target, Path path, float duration, PathMode pathMode = PathMode.Full3D + ) + { + Transform trans = target.transform; + TweenerCore t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), path, duration) + .SetTarget(target); + + t.plugOptions.isRigidbody2D = true; + t.plugOptions.mode = pathMode; + t.plugOptions.useLocalPosition = true; + return t; + } + + #endregion + + #endregion + + #endregion + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs.meta new file mode 100644 index 0000000..ee8a46f --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs.meta @@ -0,0 +1,15 @@ +fileFormatVersion: 2 +guid: 230fe34542e175245ba74b4659dae700 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs new file mode 100644 index 0000000..4d4a0c4 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs @@ -0,0 +1,93 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +#if !DOTWEEN_NOSPRITES // MODULE_MARKER +using System; +using UnityEngine; +using DG.Tweening.Core; +using DG.Tweening.Plugins.Options; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModuleSprite + { + #region Shortcuts + + #region SpriteRenderer + + /// Tweens a SpriteRenderer's color to the given value. + /// Also stores the spriteRenderer as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOColor(this SpriteRenderer target, Color endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a Material's alpha color to the given value. + /// Also stores the spriteRenderer as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOFade(this SpriteRenderer target, float endValue, float duration) + { + TweenerCore t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a SpriteRenderer's color using the given gradient + /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener). + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The gradient to useThe duration of the tween + public static Sequence DOGradientColor(this SpriteRenderer target, Gradient gradient, float duration) + { + Sequence s = DOTween.Sequence(); + GradientColorKey[] colors = gradient.colorKeys; + int len = colors.Length; + for (int i = 0; i < len; ++i) { + GradientColorKey c = colors[i]; + if (i == 0 && c.time <= 0) { + target.color = c.color; + continue; + } + float colorDuration = i == len - 1 + ? duration - s.Duration(false) // Verifies that total duration is correct + : duration * (i == 0 ? c.time : c.time - colors[i - 1].time); + s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear)); + } + s.SetTarget(target); + return s; + } + + #endregion + + #region Blendables + + #region SpriteRenderer + + /// Tweens a SpriteRenderer's color to the given value, + /// in a way that allows other DOBlendableColor tweens to work together on the same target, + /// instead than fight each other as multiple DOColor would do. + /// Also stores the SpriteRenderer as the tween's target so it can be used for filtered operations + /// The value to tween toThe duration of the tween + public static Tweener DOBlendableColor(this SpriteRenderer target, Color endValue, float duration) + { + endValue = endValue - target.color; + Color to = new Color(0, 0, 0, 0); + return DOTween.To(() => to, x => { + Color diff = x - to; + to = x; + target.color += diff; + }, endValue, duration) + .Blendable().SetTarget(target); + } + + #endregion + + #endregion + + #endregion + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs.meta new file mode 100644 index 0000000..e68222f --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs.meta @@ -0,0 +1,15 @@ +fileFormatVersion: 2 +guid: 188918ab119d93148aa0de59ccf5286b +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs new file mode 100644 index 0000000..4708449 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs @@ -0,0 +1,662 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +#if !DOTWEEN_NOUI // MODULE_MARKER + +using System; +using System.Globalization; +using UnityEngine; +using UnityEngine.UI; +using DG.Tweening.Core; +using DG.Tweening.Core.Enums; +using DG.Tweening.Plugins; +using DG.Tweening.Plugins.Options; +using Outline = UnityEngine.UI.Outline; +using Text = UnityEngine.UI.Text; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModuleUI + { + #region Shortcuts + + #region CanvasGroup + + /// Tweens a CanvasGroup's alpha color to the given value. + /// Also stores the canvasGroup as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOFade(this CanvasGroup target, float endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.alpha, x => target.alpha = x, endValue, duration); + t.SetTarget(target); + return t; + } + + #endregion + + #region Graphic + + /// Tweens an Graphic's color to the given value. + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOColor(this Graphic target, Color endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens an Graphic's alpha color to the given value. + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOFade(this Graphic target, float endValue, float duration) + { + TweenerCore t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + #endregion + + #region Image + + /// Tweens an Image's color to the given value. + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOColor(this Image target, Color endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens an Image's alpha color to the given value. + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOFade(this Image target, float endValue, float duration) + { + TweenerCore t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens an Image's fillAmount to the given value. + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The end value to reach (0 to 1)The duration of the tween + public static TweenerCore DOFillAmount(this Image target, float endValue, float duration) + { + if (endValue > 1) endValue = 1; + else if (endValue < 0) endValue = 0; + TweenerCore t = DOTween.To(() => target.fillAmount, x => target.fillAmount = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens an Image's colors using the given gradient + /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener). + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The gradient to useThe duration of the tween + public static Sequence DOGradientColor(this Image target, Gradient gradient, float duration) + { + Sequence s = DOTween.Sequence(); + GradientColorKey[] colors = gradient.colorKeys; + int len = colors.Length; + for (int i = 0; i < len; ++i) { + GradientColorKey c = colors[i]; + if (i == 0 && c.time <= 0) { + target.color = c.color; + continue; + } + float colorDuration = i == len - 1 + ? duration - s.Duration(false) // Verifies that total duration is correct + : duration * (i == 0 ? c.time : c.time - colors[i - 1].time); + s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear)); + } + s.SetTarget(target); + return s; + } + + #endregion + + #region LayoutElement + + /// Tweens an LayoutElement's flexibleWidth/Height to the given value. + /// Also stores the LayoutElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOFlexibleSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => new Vector2(target.flexibleWidth, target.flexibleHeight), x => { + target.flexibleWidth = x.x; + target.flexibleHeight = x.y; + }, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Tweens an LayoutElement's minWidth/Height to the given value. + /// Also stores the LayoutElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMinSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => new Vector2(target.minWidth, target.minHeight), x => { + target.minWidth = x.x; + target.minHeight = x.y; + }, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Tweens an LayoutElement's preferredWidth/Height to the given value. + /// Also stores the LayoutElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOPreferredSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => new Vector2(target.preferredWidth, target.preferredHeight), x => { + target.preferredWidth = x.x; + target.preferredHeight = x.y; + }, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + #endregion + + #region Outline + + /// Tweens a Outline's effectColor to the given value. + /// Also stores the Outline as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOColor(this Outline target, Color endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.effectColor, x => target.effectColor = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a Outline's effectColor alpha to the given value. + /// Also stores the Outline as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOFade(this Outline target, float endValue, float duration) + { + TweenerCore t = DOTween.ToAlpha(() => target.effectColor, x => target.effectColor = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a Outline's effectDistance to the given value. + /// Also stores the Outline as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOScale(this Outline target, Vector2 endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.effectDistance, x => target.effectDistance = x, endValue, duration); + t.SetTarget(target); + return t; + } + + #endregion + + #region RectTransform + + /// Tweens a RectTransform's anchoredPosition to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPos(this RectTransform target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + /// Tweens a RectTransform's anchoredPosition X to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPosX(this RectTransform target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(endValue, 0), duration); + t.SetOptions(AxisConstraint.X, snapping).SetTarget(target); + return t; + } + /// Tweens a RectTransform's anchoredPosition Y to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPosY(this RectTransform target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(0, endValue), duration); + t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target); + return t; + } + + /// Tweens a RectTransform's anchoredPosition3D to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPos3D(this RectTransform target, Vector3 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + /// Tweens a RectTransform's anchoredPosition3D X to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPos3DX(this RectTransform target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(endValue, 0, 0), duration); + t.SetOptions(AxisConstraint.X, snapping).SetTarget(target); + return t; + } + /// Tweens a RectTransform's anchoredPosition3D Y to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPos3DY(this RectTransform target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(0, endValue, 0), duration); + t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target); + return t; + } + /// Tweens a RectTransform's anchoredPosition3D Z to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPos3DZ(this RectTransform target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(0, 0, endValue), duration); + t.SetOptions(AxisConstraint.Z, snapping).SetTarget(target); + return t; + } + + /// Tweens a RectTransform's anchorMax to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorMax(this RectTransform target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchorMax, x => target.anchorMax = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Tweens a RectTransform's anchorMin to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorMin(this RectTransform target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchorMin, x => target.anchorMin = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Tweens a RectTransform's pivot to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOPivot(this RectTransform target, Vector2 endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.pivot, x => target.pivot = x, endValue, duration); + t.SetTarget(target); + return t; + } + /// Tweens a RectTransform's pivot X to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOPivotX(this RectTransform target, float endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.pivot, x => target.pivot = x, new Vector2(endValue, 0), duration); + t.SetOptions(AxisConstraint.X).SetTarget(target); + return t; + } + /// Tweens a RectTransform's pivot Y to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOPivotY(this RectTransform target, float endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.pivot, x => target.pivot = x, new Vector2(0, endValue), duration); + t.SetOptions(AxisConstraint.Y).SetTarget(target); + return t; + } + + /// Tweens a RectTransform's sizeDelta to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOSizeDelta(this RectTransform target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.sizeDelta, x => target.sizeDelta = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Punches a RectTransform's anchoredPosition towards the given direction and then back to the starting one + /// as if it was connected to the starting position via an elastic. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The direction and strength of the punch (added to the RectTransform's current position) + /// The duration of the tween + /// Indicates how much will the punch vibrate + /// Represents how much (0 to 1) the vector will go beyond the starting position when bouncing backwards. + /// 1 creates a full oscillation between the punch direction and the opposite direction, + /// while 0 oscillates only between the punch and the start position + /// If TRUE the tween will smoothly snap all values to integers + public static Tweener DOPunchAnchorPos(this RectTransform target, Vector2 punch, float duration, int vibrato = 10, float elasticity = 1, bool snapping = false) + { + return DOTween.Punch(() => target.anchoredPosition, x => target.anchoredPosition = x, punch, duration, vibrato, elasticity) + .SetTarget(target).SetOptions(snapping); + } + + /// Shakes a RectTransform's anchoredPosition with the given values. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The duration of the tween + /// The shake strength + /// Indicates how much will the shake vibrate + /// Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + /// Setting it to 0 will shake along a single direction. + /// If TRUE the tween will smoothly snap all values to integers + /// If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + /// Randomness mode + public static Tweener DOShakeAnchorPos(this RectTransform target, float duration, float strength = 100, int vibrato = 10, float randomness = 90, bool snapping = false, bool fadeOut = true, ShakeRandomnessMode randomnessMode = ShakeRandomnessMode.Full) + { + return DOTween.Shake(() => target.anchoredPosition, x => target.anchoredPosition = x, duration, strength, vibrato, randomness, true, fadeOut, randomnessMode) + .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetShake).SetOptions(snapping); + } + /// Shakes a RectTransform's anchoredPosition with the given values. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The duration of the tween + /// The shake strength on each axis + /// Indicates how much will the shake vibrate + /// Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + /// Setting it to 0 will shake along a single direction. + /// If TRUE the tween will smoothly snap all values to integers + /// If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + /// Randomness mode + public static Tweener DOShakeAnchorPos(this RectTransform target, float duration, Vector2 strength, int vibrato = 10, float randomness = 90, bool snapping = false, bool fadeOut = true, ShakeRandomnessMode randomnessMode = ShakeRandomnessMode.Full) + { + return DOTween.Shake(() => target.anchoredPosition, x => target.anchoredPosition = x, duration, strength, vibrato, randomness, fadeOut, randomnessMode) + .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetShake).SetOptions(snapping); + } + + #region Special + + /// Tweens a RectTransform's anchoredPosition to the given value, while also applying a jump effect along the Y axis. + /// Returns a Sequence instead of a Tweener. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reach + /// Power of the jump (the max height of the jump is represented by this plus the final Y offset) + /// Total number of jumps + /// The duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static Sequence DOJumpAnchorPos(this RectTransform target, Vector2 endValue, float jumpPower, int numJumps, float duration, bool snapping = false) + { + if (numJumps < 1) numJumps = 1; + float startPosY = 0; + float offsetY = -1; + bool offsetYSet = false; + + // Separate Y Tween so we can elaborate elapsedPercentage on that insted of on the Sequence + // (in case users add a delay or other elements to the Sequence) + Sequence s = DOTween.Sequence(); + Tween yTween = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(0, jumpPower), duration / (numJumps * 2)) + .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative() + .SetLoops(numJumps * 2, LoopType.Yoyo) + .OnStart(()=> startPosY = target.anchoredPosition.y); + s.Append(DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(endValue.x, 0), duration) + .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear) + ).Join(yTween) + .SetTarget(target).SetEase(DOTween.defaultEaseType); + s.OnUpdate(() => { + if (!offsetYSet) { + offsetYSet = true; + offsetY = s.isRelative ? endValue.y : endValue.y - startPosY; + } + Vector2 pos = target.anchoredPosition; + pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad); + target.anchoredPosition = pos; + }); + return s; + } + + #endregion + + #endregion + + #region ScrollRect + + /// Tweens a ScrollRect's horizontal/verticalNormalizedPosition to the given value. + /// Also stores the ScrollRect as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static Tweener DONormalizedPos(this ScrollRect target, Vector2 endValue, float duration, bool snapping = false) + { + return DOTween.To(() => new Vector2(target.horizontalNormalizedPosition, target.verticalNormalizedPosition), + x => { + target.horizontalNormalizedPosition = x.x; + target.verticalNormalizedPosition = x.y; + }, endValue, duration) + .SetOptions(snapping).SetTarget(target); + } + /// Tweens a ScrollRect's horizontalNormalizedPosition to the given value. + /// Also stores the ScrollRect as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static Tweener DOHorizontalNormalizedPos(this ScrollRect target, float endValue, float duration, bool snapping = false) + { + return DOTween.To(() => target.horizontalNormalizedPosition, x => target.horizontalNormalizedPosition = x, endValue, duration) + .SetOptions(snapping).SetTarget(target); + } + /// Tweens a ScrollRect's verticalNormalizedPosition to the given value. + /// Also stores the ScrollRect as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static Tweener DOVerticalNormalizedPos(this ScrollRect target, float endValue, float duration, bool snapping = false) + { + return DOTween.To(() => target.verticalNormalizedPosition, x => target.verticalNormalizedPosition = x, endValue, duration) + .SetOptions(snapping).SetTarget(target); + } + + #endregion + + #region Slider + + /// Tweens a Slider's value to the given value. + /// Also stores the Slider as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOValue(this Slider target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.value, x => target.value = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + #endregion + + #region Text + + /// Tweens a Text's color to the given value. + /// Also stores the Text as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOColor(this Text target, Color endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// + /// Tweens a Text's text from one integer to another, with options for thousands separators + /// + /// The value to start from + /// The end value to reach + /// The duration of the tween + /// If TRUE (default) also adds thousands separators + /// The to use (InvariantCulture if NULL) + public static TweenerCore DOCounter( + this Text target, int fromValue, int endValue, float duration, bool addThousandsSeparator = true, CultureInfo culture = null + ){ + int v = fromValue; + CultureInfo cInfo = !addThousandsSeparator ? null : culture ?? CultureInfo.InvariantCulture; + TweenerCore t = DOTween.To(() => v, x => { + v = x; + target.text = addThousandsSeparator + ? v.ToString("N0", cInfo) + : v.ToString(); + }, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a Text's alpha color to the given value. + /// Also stores the Text as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOFade(this Text target, float endValue, float duration) + { + TweenerCore t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a Text's text to the given value. + /// Also stores the Text as the tween's target so it can be used for filtered operations + /// The end string to tween toThe duration of the tween + /// If TRUE (default), rich text will be interpreted correctly while animated, + /// otherwise all tags will be considered as normal text + /// The type of scramble mode to use, if any + /// A string containing the characters to use for scrambling. + /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters. + /// Leave it to NULL (default) to use default ones + public static TweenerCore DOText(this Text target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null) + { + if (endValue == null) { + if (Debugger.logPriority > 0) Debugger.LogWarning("You can't pass a NULL string to DOText: an empty string will be used instead to avoid errors"); + endValue = ""; + } + TweenerCore t = DOTween.To(() => target.text, x => target.text = x, endValue, duration); + t.SetOptions(richTextEnabled, scrambleMode, scrambleChars) + .SetTarget(target); + return t; + } + + #endregion + + #region Blendables + + #region Graphic + + /// Tweens a Graphic's color to the given value, + /// in a way that allows other DOBlendableColor tweens to work together on the same target, + /// instead than fight each other as multiple DOColor would do. + /// Also stores the Graphic as the tween's target so it can be used for filtered operations + /// The value to tween toThe duration of the tween + public static Tweener DOBlendableColor(this Graphic target, Color endValue, float duration) + { + endValue = endValue - target.color; + Color to = new Color(0, 0, 0, 0); + return DOTween.To(() => to, x => { + Color diff = x - to; + to = x; + target.color += diff; + }, endValue, duration) + .Blendable().SetTarget(target); + } + + #endregion + + #region Image + + /// Tweens a Image's color to the given value, + /// in a way that allows other DOBlendableColor tweens to work together on the same target, + /// instead than fight each other as multiple DOColor would do. + /// Also stores the Image as the tween's target so it can be used for filtered operations + /// The value to tween toThe duration of the tween + public static Tweener DOBlendableColor(this Image target, Color endValue, float duration) + { + endValue = endValue - target.color; + Color to = new Color(0, 0, 0, 0); + return DOTween.To(() => to, x => { + Color diff = x - to; + to = x; + target.color += diff; + }, endValue, duration) + .Blendable().SetTarget(target); + } + + #endregion + + #region Text + + /// Tweens a Text's color BY the given value, + /// in a way that allows other DOBlendableColor tweens to work together on the same target, + /// instead than fight each other as multiple DOColor would do. + /// Also stores the Text as the tween's target so it can be used for filtered operations + /// The value to tween toThe duration of the tween + public static Tweener DOBlendableColor(this Text target, Color endValue, float duration) + { + endValue = endValue - target.color; + Color to = new Color(0, 0, 0, 0); + return DOTween.To(() => to, x => { + Color diff = x - to; + to = x; + target.color += diff; + }, endValue, duration) + .Blendable().SetTarget(target); + } + + #endregion + + #endregion + + #region Shapes + + /// Tweens a RectTransform's anchoredPosition so that it draws a circle around the given center. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations. + /// IMPORTANT: SetFrom(value) requires a instead of a float, where the X property represents the "from degrees value" + /// Circle-center/pivot around which to rotate (in UI anchoredPosition coordinates) + /// The end value degrees to reach (to rotate counter-clockwise pass a negative value) + /// The duration of the tween + /// If TRUE the coordinates will be considered as relative to the target's current anchoredPosition + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOShapeCircle( + this RectTransform target, Vector2 center, float endValueDegrees, float duration, bool relativeCenter = false, bool snapping = false + ) + { + TweenerCore t = DOTween.To( + CirclePlugin.Get(), () => target.anchoredPosition, x => target.anchoredPosition = x, center, duration + ); + t.SetOptions(endValueDegrees, relativeCenter, snapping).SetTarget(target); + return t; + } + + #endregion + + #endregion + + // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ + // ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████ + // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ + + public static class Utils + { + /// + /// Converts the anchoredPosition of the first RectTransform to the second RectTransform, + /// taking into consideration offset, anchors and pivot, and returns the new anchoredPosition + /// + public static Vector2 SwitchToRectTransform(RectTransform from, RectTransform to) + { + Vector2 localPoint; + Vector2 fromPivotDerivedOffset = new Vector2(from.rect.width * 0.5f + from.rect.xMin, from.rect.height * 0.5f + from.rect.yMin); + Vector2 screenP = RectTransformUtility.WorldToScreenPoint(null, from.position); + screenP += fromPivotDerivedOffset; + RectTransformUtility.ScreenPointToLocalPointInRectangle(to, screenP, null, out localPoint); + Vector2 pivotDerivedOffset = new Vector2(to.rect.width * 0.5f + to.rect.xMin, to.rect.height * 0.5f + to.rect.yMin); + return to.anchoredPosition + localPoint - pivotDerivedOffset; + } + } + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs.meta new file mode 100644 index 0000000..5ed23b4 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs.meta @@ -0,0 +1,15 @@ +fileFormatVersion: 2 +guid: a060394c03331a64392db53a10e7f2d1 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs new file mode 100644 index 0000000..7f07708 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs @@ -0,0 +1,161 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2026/01/08 + +#if DOTWEEN_UITOOLKIT && UNITY_2021_3_OR_NEWER // MODULE_MARKER + +using UnityEngine; +using UnityEngine.UIElements; +using DG.Tweening.Core; +using DG.Tweening.Core.Enums; +using DG.Tweening.Plugins.Options; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModuleUIToolkit + { + #region Shortcuts + + #region VisualElement + + /// Tweens a VisualElement's position (via style.translate) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMove(this VisualElement target, Vector3 endValue, float duration, bool snapping = false) + { + TweenerCore t + = DOTween.To(() => target.resolvedStyle.translate, x => target.style.translate = new Translate(x.x, x.y, x.z), endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + /// Tweens a VisualElement's position (via style.translate) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMove(this VisualElement target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t + = DOTween.To(() => (Vector2)target.resolvedStyle.translate, x => target.style.translate = new Translate(x.x, x.y, 0), endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + /// Tweens a VisualElement's X position (via style.translate) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveX(this VisualElement target, float endValue, float duration, bool snapping = false) + { + TweenerCore t + = DOTween.To(() => target.resolvedStyle.translate, x => target.style.translate = new Translate(x.x, x.y, x.z), new Vector3(endValue, 0, 0), duration); + t.SetOptions(AxisConstraint.X, snapping).SetTarget(target); + return t; + } + /// Tweens a VisualElement's Y position (via style.translate) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveY(this VisualElement target, float endValue, float duration, bool snapping = false) + { + TweenerCore t + = DOTween.To(() => target.resolvedStyle.translate, x => target.style.translate = new Translate(x.x, x.y, x.z), new Vector3(0, endValue, 0), duration); + t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target); + return t; + } + /// Tweens a VisualElement's Z position (via style.translate) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveZ(this VisualElement target, float endValue, float duration, bool snapping = false) + { + TweenerCore t + = DOTween.To(() => target.resolvedStyle.translate, x => target.style.translate = new Translate(x.x, x.y, x.z), new Vector3(0, 0, endValue), duration); + t.SetOptions(AxisConstraint.Z, snapping).SetTarget(target); + return t; + } + + /// Tweens a VisualElement's scale (via style.scale) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOScale(this VisualElement target, Vector2 endValue, float duration) + { + TweenerCore t + = DOTween.To(() => (Vector2)target.resolvedStyle.scale.value, x => target.style.scale = new Scale(x), endValue, duration); + t.SetTarget(target); + return t; + } + /// Tweens a VisualElement's scale (via style.scale) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOScale(this VisualElement target, float endValue, float duration) + { + TweenerCore t + = DOTween.To(() => (Vector2)target.resolvedStyle.scale.value, x => target.style.scale = new Scale(x), new Vector2(endValue, endValue), duration); + t.SetTarget(target); + return t; + } + + /// Tweens a VisualElement's rotation (via style.rotate) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DORotate(this VisualElement target, float endValue, float duration) + { + TweenerCore t + = DOTween.To(() => target.resolvedStyle.rotate.angle.value, x => target.style.rotate = new Rotate(x), endValue, duration); + t.SetTarget(target); + return t; + } + + /// Punches a VisualElement's position towards the given direction and then back to the starting one + /// as if it was connected to the starting position via an elastic. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The direction and strength of the punch (added to the VisualElement's current position) + /// The duration of the tween + /// Indicates how much will the punch vibrate + /// Represents how much (0 to 1) the vector will go beyond the starting position when bouncing backwards. + /// 1 creates a full oscillation between the punch direction and the opposite direction, + /// while 0 oscillates only between the punch and the start position + /// If TRUE the tween will smoothly snap all values to integers + public static Tweener DOPunch(this VisualElement target, Vector3 punch, float duration, int vibrato = 10, float elasticity = 1, bool snapping = false) + { + return DOTween.Punch(() => target.resolvedStyle.translate, x => target.style.translate = new Translate(x.x, x.y, x.z), punch, duration, vibrato, elasticity) + .SetTarget(target).SetOptions(snapping); + } + + /// Shakes a VisualElement's position with the given values. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The duration of the tween + /// The shake strength + /// Indicates how much will the shake vibrate + /// Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + /// Setting it to 0 will shake along a single direction. + /// If TRUE the tween will smoothly snap all values to integers + /// If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + /// Randomness mode + public static Tweener DOShake(this VisualElement target, float duration, float strength = 100, int vibrato = 10, float randomness = 90, bool snapping = false, bool fadeOut = true, ShakeRandomnessMode randomnessMode = ShakeRandomnessMode.Full) + { + return DOTween.Shake(() => target.resolvedStyle.translate, x => target.style.translate = new Translate(x.x, x.y, x.z), duration, strength, vibrato, randomness, true, fadeOut, randomnessMode) + .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetShake).SetOptions(snapping); + } + /// Shakes a VisualElement's position with the given values. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The duration of the tween + /// The shake strength on each axis + /// Indicates how much will the shake vibrate + /// Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + /// Setting it to 0 will shake along a single direction. + /// If TRUE the tween will smoothly snap all values to integers + /// If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + /// Randomness mode + public static Tweener DOShake(this VisualElement target, float duration, Vector2 strength, int vibrato = 10, float randomness = 90, bool snapping = false, bool fadeOut = true, ShakeRandomnessMode randomnessMode = ShakeRandomnessMode.Full) + { + return DOTween.Shake(() => target.resolvedStyle.translate, x => target.style.translate = new Translate(x.x, x.y, x.z), duration, strength, vibrato, randomness, fadeOut, randomnessMode) + .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetShake).SetOptions(snapping); + } + + #endregion + + #endregion + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs.meta new file mode 100644 index 0000000..b31220c --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs.meta @@ -0,0 +1,18 @@ +fileFormatVersion: 2 +guid: 0c0a6d2683fb84e4193f2aa968264881 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs new file mode 100644 index 0000000..8f818ba --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs @@ -0,0 +1,389 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +using System; +using UnityEngine; +using DG.Tweening.Core; +using DG.Tweening.Plugins.Options; +//#if UNITY_2018_1_OR_NEWER && (NET_4_6 || NET_STANDARD_2_0) +//using Task = System.Threading.Tasks.Task; +//#endif + +#pragma warning disable 1591 +namespace DG.Tweening +{ + /// + /// Shortcuts/functions that are not strictly related to specific Modules + /// but are available only on some Unity versions + /// + public static class DOTweenModuleUnityVersion + { + #region Material + + /// Tweens a Material's color using the given gradient + /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener). + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The gradient to useThe duration of the tween + public static Sequence DOGradientColor(this Material target, Gradient gradient, float duration) + { + Sequence s = DOTween.Sequence(); + GradientColorKey[] colors = gradient.colorKeys; + int len = colors.Length; + for (int i = 0; i < len; ++i) { + GradientColorKey c = colors[i]; + if (i == 0 && c.time <= 0) { + target.color = c.color; + continue; + } + float colorDuration = i == len - 1 + ? duration - s.Duration(false) // Verifies that total duration is correct + : duration * (i == 0 ? c.time : c.time - colors[i - 1].time); + s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear)); + } + s.SetTarget(target); + return s; + } + /// Tweens a Material's named color property using the given gradient + /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener). + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The gradient to use + /// The name of the material property to tween (like _Tint or _SpecColor) + /// The duration of the tween + public static Sequence DOGradientColor(this Material target, Gradient gradient, string property, float duration) + { + Sequence s = DOTween.Sequence(); + GradientColorKey[] colors = gradient.colorKeys; + int len = colors.Length; + for (int i = 0; i < len; ++i) { + GradientColorKey c = colors[i]; + if (i == 0 && c.time <= 0) { + target.SetColor(property, c.color); + continue; + } + float colorDuration = i == len - 1 + ? duration - s.Duration(false) // Verifies that total duration is correct + : duration * (i == 0 ? c.time : c.time - colors[i - 1].time); + s.Append(target.DOColor(c.color, property, colorDuration).SetEase(Ease.Linear)); + } + s.SetTarget(target); + return s; + } + + #endregion + + #region CustomYieldInstructions + + /// + /// Returns a that waits until the tween is killed or complete. + /// It can be used inside a coroutine as a yield. + /// Example usage:yield return myTween.WaitForCompletion(true); + /// + public static CustomYieldInstruction WaitForCompletion(this Tween t, bool returnCustomYieldInstruction) + { + if (!t.active) { + if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t); + return null; + } + return new DOTweenCYInstruction.WaitForCompletion(t); + } + + /// + /// Returns a that waits until the tween is killed or rewinded. + /// It can be used inside a coroutine as a yield. + /// Example usage:yield return myTween.WaitForRewind(); + /// + public static CustomYieldInstruction WaitForRewind(this Tween t, bool returnCustomYieldInstruction) + { + if (!t.active) { + if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t); + return null; + } + return new DOTweenCYInstruction.WaitForRewind(t); + } + + /// + /// Returns a that waits until the tween is killed. + /// It can be used inside a coroutine as a yield. + /// Example usage:yield return myTween.WaitForKill(); + /// + public static CustomYieldInstruction WaitForKill(this Tween t, bool returnCustomYieldInstruction) + { + if (!t.active) { + if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t); + return null; + } + return new DOTweenCYInstruction.WaitForKill(t); + } + + /// + /// Returns a that waits until the tween is killed or has gone through the given amount of loops. + /// It can be used inside a coroutine as a yield. + /// Example usage:yield return myTween.WaitForElapsedLoops(2); + /// + /// Elapsed loops to wait for + public static CustomYieldInstruction WaitForElapsedLoops(this Tween t, int elapsedLoops, bool returnCustomYieldInstruction) + { + if (!t.active) { + if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t); + return null; + } + return new DOTweenCYInstruction.WaitForElapsedLoops(t, elapsedLoops); + } + + /// + /// Returns a that waits until the tween is killed + /// or has reached the given time position (loops included, delays excluded). + /// It can be used inside a coroutine as a yield. + /// Example usage:yield return myTween.WaitForPosition(2.5f); + /// + /// Position (loops included, delays excluded) to wait for + public static CustomYieldInstruction WaitForPosition(this Tween t, float position, bool returnCustomYieldInstruction) + { + if (!t.active) { + if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t); + return null; + } + return new DOTweenCYInstruction.WaitForPosition(t, position); + } + + /// + /// Returns a that waits until the tween is killed or started + /// (meaning when the tween is set in a playing state the first time, after any eventual delay). + /// It can be used inside a coroutine as a yield. + /// Example usage:yield return myTween.WaitForStart(); + /// + public static CustomYieldInstruction WaitForStart(this Tween t, bool returnCustomYieldInstruction) + { + if (!t.active) { + if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t); + return null; + } + return new DOTweenCYInstruction.WaitForStart(t); + } + + #endregion + +#if UNITY_2018_1_OR_NEWER + #region Unity 2018.1 or Newer + + #region Material + + /// Tweens a Material's named texture offset property with the given ID to the given value. + /// Also stores the material as the tween's target so it can be used for filtered operations + /// The end value to reach + /// The ID of the material property to tween (also called nameID in Unity's manual) + /// The duration of the tween + public static TweenerCore DOOffset(this Material target, Vector2 endValue, int propertyID, float duration) + { + if (!target.HasProperty(propertyID)) { + if (Debugger.logPriority > 0) Debugger.LogMissingMaterialProperty(propertyID); + return null; + } + TweenerCore t = DOTween.To(() => target.GetTextureOffset(propertyID), x => target.SetTextureOffset(propertyID, x), endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a Material's named texture scale property with the given ID to the given value. + /// Also stores the material as the tween's target so it can be used for filtered operations + /// The end value to reach + /// The ID of the material property to tween (also called nameID in Unity's manual) + /// The duration of the tween + public static TweenerCore DOTiling(this Material target, Vector2 endValue, int propertyID, float duration) + { + if (!target.HasProperty(propertyID)) { + if (Debugger.logPriority > 0) Debugger.LogMissingMaterialProperty(propertyID); + return null; + } + TweenerCore t = DOTween.To(() => target.GetTextureScale(propertyID), x => target.SetTextureScale(propertyID, x), endValue, duration); + t.SetTarget(target); + return t; + } + + #endregion + + #region .NET 4.6 or Newer + +#if UNITY_2018_1_OR_NEWER && (NET_4_6 || NET_STANDARD_2_0) + + #region Async Instructions + + /// + /// Returns an async that waits until the tween is killed or complete. + /// It can be used inside an async operation. + /// Example usage:await myTween.WaitForCompletion(); + /// + public static async System.Threading.Tasks.Task AsyncWaitForCompletion(this Tween t) + { + if (!t.active) { + if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t); + return; + } + while (t.active && !t.IsComplete()) await System.Threading.Tasks.Task.Yield(); + } + + /// + /// Returns an async that waits until the tween is killed or rewinded. + /// It can be used inside an async operation. + /// Example usage:await myTween.AsyncWaitForRewind(); + /// + public static async System.Threading.Tasks.Task AsyncWaitForRewind(this Tween t) + { + if (!t.active) { + if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t); + return; + } + while (t.active && (!t.playedOnce || t.position * (t.CompletedLoops() + 1) > 0)) await System.Threading.Tasks.Task.Yield(); + } + + /// + /// Returns an async that waits until the tween is killed. + /// It can be used inside an async operation. + /// Example usage:await myTween.AsyncWaitForKill(); + /// + public static async System.Threading.Tasks.Task AsyncWaitForKill(this Tween t) + { + if (!t.active) { + if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t); + return; + } + while (t.active) await System.Threading.Tasks.Task.Yield(); + } + + /// + /// Returns an async that waits until the tween is killed or has gone through the given amount of loops. + /// It can be used inside an async operation. + /// Example usage:await myTween.AsyncWaitForElapsedLoops(); + /// + /// Elapsed loops to wait for + public static async System.Threading.Tasks.Task AsyncWaitForElapsedLoops(this Tween t, int elapsedLoops) + { + if (!t.active) { + if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t); + return; + } + while (t.active && t.CompletedLoops() < elapsedLoops) await System.Threading.Tasks.Task.Yield(); + } + + /// + /// Returns an async that waits until the tween is killed or started + /// (meaning when the tween is set in a playing state the first time, after any eventual delay). + /// It can be used inside an async operation. + /// Example usage:await myTween.AsyncWaitForPosition(); + /// + /// Position (loops included, delays excluded) to wait for + public static async System.Threading.Tasks.Task AsyncWaitForPosition(this Tween t, float position) + { + if (!t.active) { + if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t); + return; + } + while (t.active && t.position * (t.CompletedLoops() + 1) < position) await System.Threading.Tasks.Task.Yield(); + } + + /// + /// Returns an async that waits until the tween is killed. + /// It can be used inside an async operation. + /// Example usage:await myTween.AsyncWaitForKill(); + /// + public static async System.Threading.Tasks.Task AsyncWaitForStart(this Tween t) + { + if (!t.active) { + if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t); + return; + } + while (t.active && !t.playedOnce) await System.Threading.Tasks.Task.Yield(); + } + + #endregion +#endif + + #endregion + + #endregion +#endif + } + + // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ + // ███ CLASSES █████████████████████████████████████████████████████████████████████████████████████████████████████████ + // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ + + public static class DOTweenCYInstruction + { + public class WaitForCompletion : CustomYieldInstruction + { + public override bool keepWaiting { get { + return t.active && !t.IsComplete(); + }} + readonly Tween t; + public WaitForCompletion(Tween tween) + { + t = tween; + } + } + + public class WaitForRewind : CustomYieldInstruction + { + public override bool keepWaiting { get { + return t.active && (!t.playedOnce || t.position * (t.CompletedLoops() + 1) > 0); + }} + readonly Tween t; + public WaitForRewind(Tween tween) + { + t = tween; + } + } + + public class WaitForKill : CustomYieldInstruction + { + public override bool keepWaiting { get { + return t.active; + }} + readonly Tween t; + public WaitForKill(Tween tween) + { + t = tween; + } + } + + public class WaitForElapsedLoops : CustomYieldInstruction + { + public override bool keepWaiting { get { + return t.active && t.CompletedLoops() < elapsedLoops; + }} + readonly Tween t; + readonly int elapsedLoops; + public WaitForElapsedLoops(Tween tween, int elapsedLoops) + { + t = tween; + this.elapsedLoops = elapsedLoops; + } + } + + public class WaitForPosition : CustomYieldInstruction + { + public override bool keepWaiting { get { + return t.active && t.position * (t.CompletedLoops() + 1) < position; + }} + readonly Tween t; + readonly float position; + public WaitForPosition(Tween tween, float position) + { + t = tween; + this.position = position; + } + } + + public class WaitForStart : CustomYieldInstruction + { + public override bool keepWaiting { get { + return t.active && !t.playedOnce; + }} + readonly Tween t; + public WaitForStart(Tween tween) + { + t = tween; + } + } + } +} diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs.meta new file mode 100644 index 0000000..c349d90 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs.meta @@ -0,0 +1,15 @@ +fileFormatVersion: 2 +guid: 63c02322328255542995bd02b47b0457 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs new file mode 100644 index 0000000..5872cc7 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs @@ -0,0 +1,167 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +using System; +using System.Reflection; +using UnityEngine; +using DG.Tweening.Core; +using DG.Tweening.Plugins.Core.PathCore; +using DG.Tweening.Plugins.Options; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + /// + /// Utility functions that deal with available Modules and rewrite them. + /// Modules defines: + /// - DOTAUDIO + /// - DOTPHYSICS + /// - DOTPHYSICS2D + /// - DOTSPRITE + /// - DOTUI + /// Extra defines set and used for implementation of external assets: + /// - DOTWEEN_TMP ► TextMesh Pro + /// - DOTWEEN_TK2D ► 2D Toolkit + /// + public static class DOTweenModuleUtils + { + static bool _initialized; + + #region Reflection + + /// + /// Called via Reflection by DOTweenComponent on Awake + /// +#if UNITY_2018_1_OR_NEWER + [UnityEngine.Scripting.Preserve] +#endif + public static void Init() + { + if (_initialized) return; + + _initialized = true; + DOTweenExternalCommand.SetOrientationOnPath += Physics.SetOrientationOnPath; + +#if UNITY_EDITOR +#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1 + UnityEditor.EditorApplication.playmodeStateChanged += PlaymodeStateChanged; +#else + UnityEditor.EditorApplication.playModeStateChanged += PlaymodeStateChanged; +#endif +#endif + } + +#if UNITY_2018_1_OR_NEWER +#pragma warning disable + [UnityEngine.Scripting.Preserve] + // Just used to preserve methods when building, never called + static void Preserver() + { + Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies(); + MethodInfo mi = typeof(MonoBehaviour).GetMethod("Stub"); + } +#pragma warning restore +#endif + + #endregion + +#if UNITY_EDITOR + // Fires OnApplicationPause in DOTweenComponent even when Editor is paused (otherwise it's only fired at runtime) +#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1 + static void PlaymodeStateChanged() + #else + static void PlaymodeStateChanged(UnityEditor.PlayModeStateChange state) +#endif + { + if (DOTween.instance == null) return; + DOTween.instance.OnApplicationPause(UnityEditor.EditorApplication.isPaused); + } +#endif + + // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ + // ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████ + // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ + + public static class Physics + { + // Called via DOTweenExternalCommand callback + public static void SetOrientationOnPath(PathOptions options, Tween t, Quaternion newRot, Transform trans) + { +#if !DOTWEEN_NOPHYSICS // PHYSICS_MARKER + if (options.isRigidbody) ((Rigidbody)t.target).rotation = newRot; + else trans.rotation = newRot; +#else + trans.rotation = newRot; +#endif + } + + // Returns FALSE if the DOTween's Physics2D Module is disabled, or if there's no Rigidbody2D attached + public static bool HasRigidbody2D(Component target) + { +#if !DOTWEEN_NOPHYSICS2D // PHYSICS2D_MARKER + return target.GetComponent() != null; +#else + return false; +#endif + } + + #region Called via Reflection + + + // Called via Reflection by DOTweenPathInspector + // Returns FALSE if the DOTween's Physics Module is disabled, or if there's no rigidbody attached +#if UNITY_2018_1_OR_NEWER + [UnityEngine.Scripting.Preserve] +#endif + public static bool HasRigidbody(Component target) + { +#if !DOTWEEN_NOPHYSICS // PHYSICS_MARKER + return target.GetComponent() != null; +#else + return false; +#endif + } + + // Called via Reflection by DOTweenPath +#if UNITY_2018_1_OR_NEWER + [UnityEngine.Scripting.Preserve] +#endif + public static TweenerCore CreateDOTweenPathTween( + MonoBehaviour target, bool tweenRigidbody, bool isLocal, Path path, float duration, PathMode pathMode + ){ + TweenerCore t = null; + bool rBodyFoundAndTweened = false; +#if !DOTWEEN_NOPHYSICS // PHYSICS_MARKER + if (tweenRigidbody) { + Rigidbody rBody = target.GetComponent(); + if (rBody != null) { + rBodyFoundAndTweened = true; + t = isLocal + ? rBody.DOLocalPath(path, duration, pathMode) + : rBody.DOPath(path, duration, pathMode); + } + } +#endif +#if !DOTWEEN_NOPHYSICS2D // PHYSICS2D_MARKER + if (!rBodyFoundAndTweened && tweenRigidbody) { + Rigidbody2D rBody2D = target.GetComponent(); + if (rBody2D != null) { + rBodyFoundAndTweened = true; + t = isLocal + ? rBody2D.DOLocalPath(path, duration, pathMode) + : rBody2D.DOPath(path, duration, pathMode); + } + } +#endif + if (!rBodyFoundAndTweened) { + t = isLocal + ? target.transform.DOLocalPath(path, duration, pathMode) + : target.transform.DOPath(path, duration, pathMode); + } + return t; + } + + #endregion + } + } +} diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs.meta new file mode 100644 index 0000000..35fd4f9 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs.meta @@ -0,0 +1,15 @@ +fileFormatVersion: 2 +guid: 7bcaf917d9cf5b84090421a5a2abe42e +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs + uploadId: 862444 diff --git a/Assets/Plugins/Demigiant/DOTween/readme.txt b/Assets/Plugins/Demigiant/DOTween/readme.txt new file mode 100644 index 0000000..37ff7ef --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/readme.txt @@ -0,0 +1,29 @@ +DOTween and DOTween Pro are copyright (c) 2014-2018 Daniele Giardini - Demigiant + +// IMPORTANT!!! ///////////////////////////////////////////// +// Upgrading DOTween from versions older than 1.2.000 /////// +// (or DOTween Pro older than 1.0.000) ////////////////////// +------------------------------------------------------------- +If you're upgrading your project from a version of DOTween older than 1.2.000 (or DOTween Pro older than 1.0.000) please follow these instructions carefully. +1) Import the new version in the same folder as the previous one, overwriting old files. A lot of errors will appear but don't worry +2) Close and reopen Unity (and your project). This is fundamental: skipping this step will cause a bloodbath +3) Open DOTween's Utility Panel (Tools > Demigiant > DOTween Utility Panel) if it doesn't open automatically, then press "Setup DOTween...": this will run the upgrade setup +4) From the Add/Remove Modules panel that opens, activate/deactivate Modules for Unity systems and for external assets (Pro version only) + +// GET STARTED ////////////////////////////////////////////// + +- After importing a new DOTween update, select DOTween's Utility Panel from the "Tools/Demigiant" menu (if it doesn't open automatically) and press the "Setup DOTween..." button to activate/deactivate Modules. You can also access a Preferences Tab from there to choose default settings for DOTween. +- In your code, add "using DG.Tweening" to each class where you want to use DOTween. +- You're ready to tween. Check out the links below for full documentation and license info. + + +// LINKS /////////////////////////////////////////////////////// + +DOTween website (documentation, examples, etc): http://dotween.demigiant.com +DOTween license: http://dotween.demigiant.com/license.php +DOTween repository (Google Code): https://code.google.com/p/dotween/ +Demigiant website (documentation, examples, etc): http://www.demigiant.com + +// NOTES ////////////////////////////////////////////////////// + +- DOTween's Utility Panel can be found under "Tools > Demigiant > DOTween Utility Panel" and also contains other useful options, plus a tab to set DOTween's preferences \ No newline at end of file diff --git a/Assets/Plugins/Demigiant/DOTween/readme.txt.meta b/Assets/Plugins/Demigiant/DOTween/readme.txt.meta new file mode 100644 index 0000000..f91ab48 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/readme.txt.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fccfc62abf2eb0a4db614853430894fd +TextScriptImporter: + userData: +AssetOrigin: + serializedVersion: 1 + productId: 27676 + packageName: DOTween (HOTween v2) + packageVersion: 1.2.825 + assetPath: Assets/Plugins/Demigiant/DOTween/readme.txt + uploadId: 862444