From 051a71ac15fef08c573428f30cc9ffc743e43eaf Mon Sep 17 00:00:00 2001 From: cooney Date: Tue, 13 Jan 2026 02:13:18 +0900 Subject: [PATCH] =?UTF-8?q?=EC=9C=88=EB=8F=84=EC=9A=B0=EC=97=90=EC=84=9C?= =?UTF-8?q?=20=EC=9B=90=ED=95=98=EB=8A=94=20=EB=AA=A8=EB=8B=88=ED=84=B0?= =?UTF-8?q?=EC=9D=98=20=EC=A0=95=EB=B3=B4=EB=A5=BC=20=EB=B0=9B=EC=95=84?= =?UTF-8?q?=EC=98=A8=20=ED=9B=84=20=EC=8A=A4=ED=81=AC=EB=A6=B0=EC=83=B7=20?= =?UTF-8?q?=EC=B4=AC=EC=98=81=20=EA=B8=B0=EB=8A=A5=20=EC=B6=94=EA=B0=80=20?= =?UTF-8?q?=EC=9C=A0=EB=8B=88=ED=8B=B0=20=EC=9C=88=EB=8F=84=EC=9A=B0=20?= =?UTF-8?q?=EB=8B=A4=ED=81=AC=20=ED=85=8C=EB=A7=88=20=EB=B0=8F=20DOTween?= =?UTF-8?q?=20=EC=97=90=EC=85=8B=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Assets/Main.unity | 21 +- 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 | 144 + .../DOTween/Editor/DOTweenEditor.XML.meta | 11 + .../DOTween/Editor/DOTweenEditor.dll | Bin 0 -> 70656 bytes .../DOTween/Editor/DOTweenEditor.dll.meta | 29 + .../DOTween/Editor/DOTweenUpgradeManager.XML | 14 + .../Editor/DOTweenUpgradeManager.XML.meta | 11 + .../DOTween/Editor/DOTweenUpgradeManager.dll | Bin 0 -> 10752 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 + .../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 + Assets/Plugins/UnityEditorDarkMode.meta | 8 + Assets/Plugins/UnityEditorDarkMode/README.txt | 40 + .../UnityEditorDarkMode/README.txt.meta | 14 + .../UnityEditorDarkMode.dll | Bin 0 -> 79360 bytes .../UnityEditorDarkMode.dll.ini | 6 + .../UnityEditorDarkMode.dll.ini.meta | 14 + .../UnityEditorDarkMode.dll.meta | 70 + Assets/Scripts/TakeScreen.cs | 169 +- ProjectSettings/ProjectSettings.asset | 20 +- 56 files changed, 6274 insertions(+), 44 deletions(-) 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/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 create mode 100644 Assets/Plugins/UnityEditorDarkMode.meta create mode 100644 Assets/Plugins/UnityEditorDarkMode/README.txt create mode 100644 Assets/Plugins/UnityEditorDarkMode/README.txt.meta create mode 100644 Assets/Plugins/UnityEditorDarkMode/UnityEditorDarkMode.dll create mode 100644 Assets/Plugins/UnityEditorDarkMode/UnityEditorDarkMode.dll.ini create mode 100644 Assets/Plugins/UnityEditorDarkMode/UnityEditorDarkMode.dll.ini.meta create mode 100644 Assets/Plugins/UnityEditorDarkMode/UnityEditorDarkMode.dll.meta diff --git a/Assets/Main.unity b/Assets/Main.unity index 7b2dfb2..d33884e 100644 --- a/Assets/Main.unity +++ b/Assets/Main.unity @@ -456,7 +456,19 @@ MonoBehaviour: m_TargetGraphic: {fileID: 240954701} m_OnClick: m_PersistentCalls: - m_Calls: [] + m_Calls: + - m_Target: {fileID: 240954703} + m_TargetAssemblyTypeName: TakeScreen, Assembly-CSharp + m_MethodName: Take + m_Mode: 1 + m_Arguments: + m_ObjectArgument: {fileID: 0} + m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine + m_IntArgument: 0 + m_FloatArgument: 0 + m_StringArgument: + m_BoolArgument: 0 + m_CallState: 2 --- !u!114 &240954701 MonoBehaviour: m_ObjectHideFlags: 0 @@ -507,8 +519,11 @@ MonoBehaviour: m_Script: {fileID: 11500000, guid: 2f7f5eee1f8301c468e96d926d39fa52, type: 3} m_Name: m_EditorClassIdentifier: Assembly-CSharp::TakeScreen - monitorIndex: 0 - directorySelector: {fileID: 0} + selectMonitorIndex: 2 + takeNumber: 0 + inputPrefix: {fileID: 56188227} + inputResult: {fileID: 0} + directorySelector: {fileID: 1438379834} --- !u!1 &519420028 GameObject: m_ObjectHideFlags: 0 diff --git a/Assets/Plugins.meta b/Assets/Plugins.meta new file mode 100644 index 0000000..09d2b66 --- /dev/null +++ b/Assets/Plugins.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 11fa134210a4e324aaf99c3c0f3d3a6b +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..4691b03 --- /dev/null +++ b/Assets/Plugins/Demigiant.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: d4fb1de9b00bfac42af0a35ff2a01f89 +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..0e797fe --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/DOTween.XML + uploadId: 831234 diff --git a/Assets/Plugins/Demigiant/DOTween/DOTween.dll b/Assets/Plugins/Demigiant/DOTween/DOTween.dll new file mode 100644 index 0000000000000000000000000000000000000000..73235fc01a2d43cf393d9d7c897be3924bbbefeb GIT binary patch literal 177664 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�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 + + + 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 + + + + 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..a34b5a8 --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML + uploadId: 831234 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll new file mode 100644 index 0000000000000000000000000000000000000000..c2d87f934f951d96c83020e8dd51cc058c5ad46e GIT binary patch literal 70656 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 + + + 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..e086eae --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.XML + uploadId: 831234 diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.dll b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenUpgradeManager.dll new file mode 100644 index 0000000000000000000000000000000000000000..7485311e8ef809509c8adb704ab50efb2a6248c6 GIT binary patch literal 10752 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 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..d763306 --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png + uploadId: 831234 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..4314c3c --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenMiniIcon.png + uploadId: 831234 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..f8d3705 --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png + uploadId: 831234 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..93e5f95 --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png + uploadId: 831234 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..f5981c5 --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg + uploadId: 831234 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..d958ae0 --- /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 true // 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..ddb7ef3 --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs + uploadId: 831234 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs new file mode 100644 index 0000000..2ab3775 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs @@ -0,0 +1,146 @@ +using UnityEngine; + +#if false || 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..af2843d --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs + uploadId: 831234 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs new file mode 100644 index 0000000..08b0700 --- /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 true // MODULE_MARKER +using System; +using DG.Tweening.Core; +using DG.Tweening.Core.Enums; +using DG.Tweening.Plugins; +using DG.Tweening.Plugins.Core.PathCore; +using DG.Tweening.Plugins.Options; +using UnityEngine; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModulePhysics + { + #region Shortcuts + + #region Rigidbody + + /// 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..2081c84 --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs + uploadId: 831234 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs new file mode 100644 index 0000000..8ce2b56 --- /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 true // 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..a730580 --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs + uploadId: 831234 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs new file mode 100644 index 0000000..72afb7b --- /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 true // 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..bf1392e --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs + uploadId: 831234 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs new file mode 100644 index 0000000..2381f4c --- /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 true // 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..7aaa07e --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs + uploadId: 831234 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..6c3c674 --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs + uploadId: 831234 diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs new file mode 100644 index 0000000..12a365d --- /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. + /// 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 true // PHYSICS_MARKER + if (options.isRigidbody) ((Rigidbody)t.target).rotation = newRot; + else trans.rotation = newRot; +#else + trans.rotation = newRot; +#endif + } + + // Returns FALSE if the DOTween's Physics2D Module is disabled, or if there's no Rigidbody2D attached + public static bool HasRigidbody2D(Component target) + { +#if true // PHYSICS2D_MARKER + return target.GetComponent() != null; +#else + return false; +#endif + } + + #region Called via Reflection + + + // Called via Reflection by DOTweenPathInspector + // Returns FALSE if the DOTween's Physics Module is disabled, or if there's no rigidbody attached +#if UNITY_2018_1_OR_NEWER + [UnityEngine.Scripting.Preserve] +#endif + public static bool HasRigidbody(Component target) + { +#if true // PHYSICS_MARKER + return target.GetComponent() != 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 true // 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 true // 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..f92deb9 --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs + uploadId: 831234 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..a1ba904 --- /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.790 + assetPath: Assets/Plugins/Demigiant/DOTween/readme.txt + uploadId: 831234 diff --git a/Assets/Plugins/UnityEditorDarkMode.meta b/Assets/Plugins/UnityEditorDarkMode.meta new file mode 100644 index 0000000..07a1fe8 --- /dev/null +++ b/Assets/Plugins/UnityEditorDarkMode.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 3e722869deff58e4cae41190ceee880a +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Plugins/UnityEditorDarkMode/README.txt b/Assets/Plugins/UnityEditorDarkMode/README.txt new file mode 100644 index 0000000..11e3627 --- /dev/null +++ b/Assets/Plugins/UnityEditorDarkMode/README.txt @@ -0,0 +1,40 @@ +DarkMode Mod for Unity Editor on Windows +---------------------------------------------------------------------------- +v1.1 04/08/2024 +---------------------------------------------------------------------------- + +A fully working runtime dark mode mod for Unity Editor on Windows with: + + - Dark title bar + - Dark menu bar + - Dark context menu + - And more... + +> This runtime mod works on Windows 11 and Windows 10 1903+. + Tested on Unity 2019, 2020, 2021, 2022, 2023 and Unity 6. + +Source code is available at: https://github.com/0x7c13/UnityEditor-DarkMode + +---------------------------------------------------------------------------- + +MIT License + +Copyright (c) 2024 Jiaqi (0x7c13) Liu + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/Assets/Plugins/UnityEditorDarkMode/README.txt.meta b/Assets/Plugins/UnityEditorDarkMode/README.txt.meta new file mode 100644 index 0000000..f6ed178 --- /dev/null +++ b/Assets/Plugins/UnityEditorDarkMode/README.txt.meta @@ -0,0 +1,14 @@ +fileFormatVersion: 2 +guid: 33d8f76296a183145ae27b820db1e4b4 +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: +AssetOrigin: + serializedVersion: 1 + productId: 281842 + packageName: DarkMode for Unity Editor on Windows + packageVersion: 1.1 + assetPath: Assets/Plugins/UnityEditorDarkMode/README.txt + uploadId: 656109 diff --git a/Assets/Plugins/UnityEditorDarkMode/UnityEditorDarkMode.dll b/Assets/Plugins/UnityEditorDarkMode/UnityEditorDarkMode.dll new file mode 100644 index 0000000000000000000000000000000000000000..4a7f1e300f1f472ecf42dc71c9dad001bbd48417 GIT binary patch literal 79360 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 screens.Length) + if (GetMonitorInfo(hMonitor, ref mi) && monitorIndex == selectMonitorIndex) { - Debug.Log("잘못된 모니터 인덱스입니다."); - return; - } - - // 해당 모니터 정보 - Screen targetScreen = screens[index]; - Rectangle bounds = targetScreen.Bounds; - - // 비트맵 생성 - using (Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height)) - { - using (Graphics g = Graphics.FromImage(bitmap)) - { - g.CopyFromScreen(bounds.X, bounds.Y, 0, 0, bounds.Size); - } + int width = mi.rcMonitor.right - mi.rcMonitor.left; + int height = mi.rcMonitor.bottom - mi.rcMonitor.top; + bool isPrimary = (mi.dwFlags & 1) != 0; - // png로 저장 - bitmap.Save(savePath, ImageFormat.Png); + Debug.Log( + $"{mi.szDevice} 모니터 \n" + + $" - 해상도 : {width} x {height}\n" + + $" - 위치 : x = {mi.rcMonitor.left}, y = {mi.rcMonitor.top}\n" + + $" - 주 모니터 여부 : {isPrimary}\n" + ); + + selectMonitor = mi; + selectWidth = width; + selectHeight = height; } + + return true; // 계속 나머지 모니터 순회 + } + + public void Take() + { + string fileName = $"{inputPrefix.text}_{string.Format("{0:D2}", takeNumber)}.png"; + string savePath = Path.Combine(directorySelector.selectedFolderPath, fileName); + + Shot(selectMonitor.rcMonitor.left, selectMonitor.rcMonitor.top, selectWidth, selectHeight, savePath); + } + + void Shot(int x, int y, int width, int height, string savePath) + { + IntPtr desktopDC = GetDC(IntPtr.Zero); + IntPtr memoryDC = CreateCompatibleDC(desktopDC); + IntPtr bitmap = CreateCompatibleBitmap(desktopDC, width, height); + IntPtr oldBitmap = SelectObject(memoryDC, bitmap); + + BitBlt(memoryDC, 0, 0, width, height, desktopDC, x, y, CopyPixelOperation.SourceCopy | CopyPixelOperation.CaptureBlt); + + using (Bitmap bmp = Image.FromHbitmap(bitmap)) + { + bmp.Save(savePath, ImageFormat.Png); + } + + // 정리 + SelectObject(memoryDC, oldBitmap); + DeleteObject(bitmap); + DeleteDC(memoryDC); + ReleaseDC(desktopDC, memoryDC); + + inputResult.text = savePath; } } diff --git a/ProjectSettings/ProjectSettings.asset b/ProjectSettings/ProjectSettings.asset index 473c958..2daa1e1 100644 --- a/ProjectSettings/ProjectSettings.asset +++ b/ProjectSettings/ProjectSettings.asset @@ -581,7 +581,25 @@ PlayerSettings: webGLCloseOnQuit: 0 webWasm2023: 0 webEnableSubmoduleStrippingCompatibility: 0 - scriptingDefineSymbols: {} + scriptingDefineSymbols: + Android: DOTWEEN + EmbeddedLinux: DOTWEEN + GameCoreScarlett: DOTWEEN + GameCoreXboxOne: DOTWEEN + Kepler: DOTWEEN + LinuxHeadlessSimulation: DOTWEEN + Nintendo Switch: DOTWEEN + PS4: DOTWEEN + PS5: DOTWEEN + QNX: DOTWEEN + ReservedCFE: DOTWEEN + Standalone: DOTWEEN + VisionOS: DOTWEEN + WebGL: DOTWEEN + Windows Store Apps: DOTWEEN + XboxOne: DOTWEEN + iPhone: DOTWEEN + tvOS: DOTWEEN additionalCompilerArguments: {} platformArchitecture: {} scriptingBackend: