From 6b8982f0cdf01a1a38b7a6808bb24f39e21acb76 Mon Sep 17 00:00:00 2001 From: SepComet <202308010230@stu.csust.edu.cn> Date: Sun, 8 Feb 2026 18:02:11 +0800 Subject: [PATCH] =?UTF-8?q?=E5=BC=95=E5=85=A5=20DOTween=20=E6=9D=A5?= =?UTF-8?q?=E5=AE=9E=E7=8E=B0=E9=83=A8=E5=88=86=E5=8A=A8=E7=94=BB=EF=BC=8C?= =?UTF-8?q?=E5=85=B7=E4=BD=93=E6=9C=89=EF=BC=9A=20-=20=E9=BC=A0=E6=A0=87?= =?UTF-8?q?=E4=B8=8E=20Part=20=E4=BA=A4=E4=BA=92=E6=97=B6=E7=9A=84?= =?UTF-8?q?=E7=BC=A9=E6=94=BE=20-=20Part=20=E6=94=BE=E7=BD=AE=E5=A4=B1?= =?UTF-8?q?=E8=B4=A5=E5=9B=9E=E5=88=B0=E5=8E=9F=E4=BD=8D=E7=9A=84=E4=BD=8D?= =?UTF-8?q?=E7=A7=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../UI/GameplayA/View/CombineDraggablePart.cs | 143 +- .../Scripts/UI/GameplayA/View/CombineForm.cs | 63 +- .../Scripts/UI/GameplayA/View/CombineSlot.cs | 9 +- 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 | 4 + Assets/Plugins/Demigiant/DOTween/DOTween.dll | Bin 0 -> 177664 bytes .../Demigiant/DOTween/DOTween.dll.meta | 22 + Assets/Plugins/Demigiant/DOTween/Editor.meta | 5 + .../DOTween/Editor/DOTweenEditor.XML | 165 + .../DOTween/Editor/DOTweenEditor.XML.meta | 4 + .../DOTween/Editor/DOTweenEditor.dll | Bin 0 -> 66560 bytes .../DOTween/Editor/DOTweenEditor.dll.meta | 22 + .../Demigiant/DOTween/Editor/Imgs.meta | 5 + .../DOTween/Editor/Imgs/DOTweenIcon.png | Bin 0 -> 1565 bytes .../DOTween/Editor/Imgs/DOTweenIcon.png.meta | 47 + .../DOTween/Editor/Imgs/DOTweenMiniIcon.png | Bin 0 -> 319 bytes .../Editor/Imgs/DOTweenMiniIcon.png.meta | 68 + .../Demigiant/DOTween/Editor/Imgs/Footer.png | Bin 0 -> 4409 bytes .../DOTween/Editor/Imgs/Footer.png.meta | 47 + .../DOTween/Editor/Imgs/Footer_dark.png | Bin 0 -> 4429 bytes .../DOTween/Editor/Imgs/Footer_dark.png.meta | 47 + .../Demigiant/DOTween/Editor/Imgs/Header.jpg | Bin 0 -> 22787 bytes .../DOTween/Editor/Imgs/Header.jpg.meta | 47 + Assets/Plugins/Demigiant/DOTween/Modules.meta | 5 + .../DOTween/Modules/DOTweenModuleAudio.cs | 198 ++ .../Modules/DOTweenModuleAudio.cs.meta | 8 + .../Modules/DOTweenModuleEPOOutline.cs | 146 + .../Modules/DOTweenModuleEPOOutline.cs.meta | 12 + .../DOTween/Modules/DOTweenModulePhysics.cs | 216 ++ .../Modules/DOTweenModulePhysics.cs.meta | 8 + .../DOTween/Modules/DOTweenModulePhysics2D.cs | 193 + .../Modules/DOTweenModulePhysics2D.cs.meta | 8 + .../DOTween/Modules/DOTweenModuleSprite.cs | 93 + .../Modules/DOTweenModuleSprite.cs.meta | 8 + .../DOTween/Modules/DOTweenModuleUI.cs | 662 ++++ .../DOTween/Modules/DOTweenModuleUI.cs.meta | 8 + .../DOTween/Modules/DOTweenModuleUIToolkit.cs | 113 + .../Modules/DOTweenModuleUIToolkit.cs.meta | 11 + .../Modules/DOTweenModuleUnityVersion.cs | 389 +++ .../Modules/DOTweenModuleUnityVersion.cs.meta | 8 + .../DOTween/Modules/DOTweenModuleUtils.cs | 167 + .../Modules/DOTweenModuleUtils.cs.meta | 8 + Assets/Plugins/Demigiant/DOTween/readme.txt | 29 + .../Plugins/Demigiant/DOTween/readme.txt.meta | 4 + Assets/Resources.meta | 8 + Assets/Resources/DOTweenSettings.asset | 55 + Assets/Resources/DOTweenSettings.asset.meta | 8 + 50 files changed, 6201 insertions(+), 6 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/Imgs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenMiniIcon.png create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenMiniIcon.png.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg create mode 100644 Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs create mode 100644 Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs.meta create mode 100644 Assets/Plugins/Demigiant/DOTween/readme.txt create mode 100644 Assets/Plugins/Demigiant/DOTween/readme.txt.meta create mode 100644 Assets/Resources.meta create mode 100644 Assets/Resources/DOTweenSettings.asset create mode 100644 Assets/Resources/DOTweenSettings.asset.meta diff --git a/Assets/GameMain/Scripts/UI/GameplayA/View/CombineDraggablePart.cs b/Assets/GameMain/Scripts/UI/GameplayA/View/CombineDraggablePart.cs index fbdf842..746a1ee 100644 --- a/Assets/GameMain/Scripts/UI/GameplayA/View/CombineDraggablePart.cs +++ b/Assets/GameMain/Scripts/UI/GameplayA/View/CombineDraggablePart.cs @@ -1,4 +1,5 @@ using CustomComponent; +using DG.Tweening; using Definition.Enum; using UnityEngine; using UnityEngine.EventSystems; @@ -10,7 +11,7 @@ namespace UI /// [RequireComponent(typeof(RectTransform))] [DisallowMultipleComponent] - public class CombineDraggablePart : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler + public class CombineDraggablePart : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler, IPointerEnterHandler, IPointerExitHandler { #region Inspector Config @@ -26,6 +27,18 @@ namespace UI [SerializeField] private CanvasGroup _canvasGroup; + [SerializeField] private float _defaultScaleMultiplier = 0.8f; + + [SerializeField] private float _hoverScaleMultiplier = 1f; + + [SerializeField] private float _hoverTweenDuration = 0.15f; + + [SerializeField] private Ease _hoverTweenEase = Ease.OutQuad; + + [SerializeField] private float _returnToSpawnDuration = 0.4f; + + [SerializeField] private Ease _returnToSpawnEase = Ease.OutCubic; + #endregion #region Spawn State @@ -54,6 +67,14 @@ namespace UI private bool _isLocked; + private bool _isDragging; + + private Vector3 _originalLocalScale = Vector3.one; + + private Tween _scaleTween; + + private Tween _returnTween; + #endregion #region Public Query @@ -64,6 +85,32 @@ namespace UI #endregion + #region Unity Lifecycle + + private void Awake() + { + if (_rectTransform == null) + { + _rectTransform = transform as RectTransform; + } + + if (_canvasGroup == null) + { + _canvasGroup = gameObject.GetOrAddComponent(); + } + + _originalLocalScale = _rectTransform.localScale; + ApplyScaleImmediate(_defaultScaleMultiplier); + } + + private void OnDestroy() + { + KillScaleTween(); + KillReturnTween(); + } + + #endregion + #region Setup /// @@ -111,6 +158,7 @@ namespace UI public void ResetToSpawn() { ClearSlotOccupancy(); + _isDragging = false; _isPlaced = false; _isLocked = false; ReturnToSpawn(); @@ -130,6 +178,8 @@ namespace UI return; } + KillReturnTween(); + _isDragging = true; _canvasGroup.blocksRaycasts = false; MoveToDragRoot(); _rectTransform.SetAsLastSibling(); @@ -153,6 +203,8 @@ namespace UI /// public void OnEndDrag(PointerEventData eventData) { + _isDragging = false; + if (_isLocked) { return; @@ -162,10 +214,30 @@ namespace UI if (!_isPlaced) { - ReturnToSpawn(); + ReturnToSpawnAnimated(); } } + public void OnPointerEnter(PointerEventData eventData) + { + if (_isLocked || _isPlaced || _isDragging) + { + return; + } + + PlayScaleTween(_hoverScaleMultiplier); + } + + public void OnPointerExit(PointerEventData eventData) + { + if (_isLocked || _isPlaced || _isDragging) + { + return; + } + + PlayScaleTween(_defaultScaleMultiplier); + } + /// /// 校验是否允许开始拖拽。 /// @@ -208,6 +280,8 @@ namespace UI /// public void ReturnToSpawn() { + KillReturnTween(); + if (_spawnParent == null) { return; @@ -225,6 +299,9 @@ namespace UI /// internal void PlaceToSlot(CombineSlot slot) { + KillScaleTween(); + KillReturnTween(); + _isDragging = false; _currentSlot = slot; _isPlaced = true; _isLocked = _lockAfterPlaced; @@ -249,6 +326,66 @@ namespace UI } } + private void ApplyScaleImmediate(float multiplier) + { + _rectTransform.localScale = _originalLocalScale * Mathf.Max(0f, multiplier); + } + + private void PlayScaleTween(float targetMultiplier) + { + KillScaleTween(); + _scaleTween = _rectTransform + .DOScale(_originalLocalScale * Mathf.Max(0f, targetMultiplier), _hoverTweenDuration) + .SetEase(_hoverTweenEase) + .SetUpdate(true); + } + + private void ReturnToSpawnAnimated() + { + if (_spawnParent == null) + { + return; + } + + if (_returnToSpawnDuration <= 0f) + { + ReturnToSpawn(); + return; + } + + KillReturnTween(); + _rectTransform.SetParent(_spawnParent, true); + _rectTransform.SetSiblingIndex(_spawnSiblingIndex); + + _returnTween = DOTween.Sequence() + .Append(_rectTransform.DOMove(_spawnWorldPosition, _returnToSpawnDuration)) + .Join(_rectTransform.DORotateQuaternion(_spawnWorldRotation, _returnToSpawnDuration)) + .Join(_rectTransform.DOScale(_spawnWorldScale, _returnToSpawnDuration)) + .SetEase(_returnToSpawnEase) + .SetUpdate(true) + .OnKill(() => _returnTween = null); + } + + private void KillScaleTween() + { + if (_scaleTween != null && _scaleTween.IsActive()) + { + _scaleTween.Kill(); + } + + _scaleTween = null; + } + + private void KillReturnTween() + { + if (_returnTween != null && _returnTween.IsActive()) + { + _returnTween.Kill(); + } + + _returnTween = null; + } + #endregion } -} \ No newline at end of file +} diff --git a/Assets/GameMain/Scripts/UI/GameplayA/View/CombineForm.cs b/Assets/GameMain/Scripts/UI/GameplayA/View/CombineForm.cs index 5844bd2..d68d1ee 100644 --- a/Assets/GameMain/Scripts/UI/GameplayA/View/CombineForm.cs +++ b/Assets/GameMain/Scripts/UI/GameplayA/View/CombineForm.cs @@ -39,6 +39,14 @@ namespace UI [SerializeField] private float _partVerticalSpacing = 120f; + [SerializeField] [Range(0f, 1f)] private float _partSpawnMinXNormalized = 0.55f; + + [SerializeField] [Range(0f, 1f)] private float _partSpawnMaxXNormalized = 0.95f; + + [SerializeField] [Range(0f, 1f)] private float _partSpawnMinYNormalized = 0.1f; + + [SerializeField] [Range(0f, 1f)] private float _partSpawnMaxYNormalized = 0.9f; + private readonly List _runtimeNodes = new(); #endregion @@ -194,14 +202,65 @@ namespace UI _runtimeNodes.Add(slot.gameObject); } - foreach (var partData in context.Parts) + List partContexts = BuildPartContextList(context); + for (int i = 0; i < partContexts.Count; i++) { + CombinePartContext partData = partContexts[i]; CombineDraggablePart part = Instantiate(_partPrefab, _partRoot, false); part.Initialize(partData); + SetPartSpawnPosition(part, i); _runtimeNodes.Add(part.gameObject); } } + private List BuildPartContextList(CombineFormContext context) + { + if (context.Parts != null && context.Parts.Count > 0) + { + return context.Parts; + } + + List fallbackParts = new List(context.Slots.Count); + for (int i = 0; i < context.Slots.Count; i++) + { + CombineSlotContext slot = context.Slots[i]; + fallbackParts.Add(new CombinePartContext + { + PartType = slot.RequiredPartType, + PartDisplayName = slot.RequiredPartType.ToString(), + MechanicsExplanation = slot.MechanicsExplanation, + LockAfterPlaced = true + }); + } + + return fallbackParts; + } + + private void SetPartSpawnPosition(CombineDraggablePart part, int index) + { + RectTransform partRect = part.transform as RectTransform; + if (partRect == null || _partRoot == null) + { + return; + } + + Rect rootRect = _partRoot.rect; + if (rootRect.width <= 0f || rootRect.height <= 0f) + { + partRect.anchoredPosition = _partStartAnchoredPosition + Vector2.down * (_partVerticalSpacing * index); + return; + } + + float minX = Mathf.Lerp(rootRect.xMin, rootRect.xMax, Mathf.Min(_partSpawnMinXNormalized, _partSpawnMaxXNormalized)); + float maxX = Mathf.Lerp(rootRect.xMin, rootRect.xMax, Mathf.Max(_partSpawnMinXNormalized, _partSpawnMaxXNormalized)); + float minY = Mathf.Lerp(rootRect.yMin, rootRect.yMax, Mathf.Min(_partSpawnMinYNormalized, _partSpawnMaxYNormalized)); + float maxY = Mathf.Lerp(rootRect.yMin, rootRect.yMax, Mathf.Max(_partSpawnMinYNormalized, _partSpawnMaxYNormalized)); + + partRect.anchoredPosition = new Vector2( + Random.Range(minX, maxX), + Random.Range(minY, maxY)); + } + #endregion #region Event Handlers @@ -244,4 +303,4 @@ namespace UI #endregion } -} \ No newline at end of file +} diff --git a/Assets/GameMain/Scripts/UI/GameplayA/View/CombineSlot.cs b/Assets/GameMain/Scripts/UI/GameplayA/View/CombineSlot.cs index 73c1183..1cdb94d 100644 --- a/Assets/GameMain/Scripts/UI/GameplayA/View/CombineSlot.cs +++ b/Assets/GameMain/Scripts/UI/GameplayA/View/CombineSlot.cs @@ -118,6 +118,13 @@ namespace UI _requireStrictOrder = data.RequireStrictOrder; _mechanicsExplanation = data.MechanicsExplanation ?? string.Empty; _mismatchHint = data.MismatchHint ?? string.Empty; + + RectTransform rectTransform = transform as RectTransform; + if (rectTransform != null) + { + rectTransform.anchoredPosition = data.AnchoredPosition; + rectTransform.sizeDelta = data.SizeDelta; + } } /// @@ -192,4 +199,4 @@ namespace UI #endregion } -} \ No newline at end of file +} diff --git a/Assets/Plugins.meta b/Assets/Plugins.meta new file mode 100644 index 0000000..881fd2c --- /dev/null +++ b/Assets/Plugins.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: c45a565dc451b0148a2472bb0058e322 +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..93315d8 --- /dev/null +++ b/Assets/Plugins/Demigiant.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 239ad8accb53b2440ac9ca35b12fc1e9 +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..7a866b5 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/DOTween.XML.meta @@ -0,0 +1,4 @@ +fileFormatVersion: 2 +guid: 34192c5e0d14aee43a0e86cc4823268a +TextScriptImporter: + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/DOTween.dll b/Assets/Plugins/Demigiant/DOTween/DOTween.dll new file mode 100644 index 0000000000000000000000000000000000000000..1216c58d53f75a662b4ec6d4be03903826309d60 GIT binary patch literal 177664 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 C-~g%s literal 0 HcmV?d00001 diff --git a/Assets/Plugins/Demigiant/DOTween/DOTween.dll.meta b/Assets/Plugins/Demigiant/DOTween/DOTween.dll.meta new file mode 100644 index 0000000..482dbb8 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/DOTween.dll.meta @@ -0,0 +1,22 @@ +fileFormatVersion: 2 +guid: a811bde74b26b53498b4f6d872b09b6d +PluginImporter: + serializedVersion: 1 + iconMap: {} + executionOrder: {} + isPreloaded: 0 + platformData: + Any: + enabled: 1 + settings: {} + Editor: + enabled: 0 + settings: + DefaultValueInitialized: true + WindowsStoreApps: + enabled: 0 + settings: + CPU: AnyCPU + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Plugins/Demigiant/DOTween/Editor.meta b/Assets/Plugins/Demigiant/DOTween/Editor.meta new file mode 100644 index 0000000..532edfb --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor.meta @@ -0,0 +1,5 @@ +fileFormatVersion: 2 +guid: b27f58ae5d5c33a4bb2d1f4f34bd036d +folderAsset: yes +DefaultImporter: + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML new file mode 100644 index 0000000..b893a67 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML @@ -0,0 +1,165 @@ + + + + DOTweenEditor + + + + + Contains compatibility methods taken from DemiEditor (for when DOTween is without it) + + + + + Warning: some versions of this method don't have the includeInactive parameter so it won't be taken into account + + + + + Warning: some versions of this method don't have the includeInactive parameter so it won't be taken into account + + + + + Warning: some versions of this method don't have the includeInactive parameter so it won't be taken into account + + + + + Warning: some versions of this method don't have the includeInactive parameter so it won't be taken into account + + + + + Starts the update loop of tween in the editor. Has no effect during playMode. + + Eventual callback to call after every update + + + + Stops the update loop and clears the onPreviewUpdated callback. + + If TRUE also resets the tweened objects to their original state. + Note that this works by calling Rewind on all tweens, so it will work correctly + only if you have a single tween type per object and it wasn't killed + If TRUE also kills any cached tween + + + + Readies the tween for editor preview by setting its UpdateType to Manual plus eventual extra settings. + + The tween to ready + If TRUE (recommended) removes all callbacks (OnComplete/Rewind/etc) + If TRUE prevents the tween from being auto-killed at completion + If TRUE starts playing the tween immediately + + + Full major version + first minor version (ex: 2018.1f) + + + Major version + + + First minor version (ex: in 2018.1 it would be 1) + + + + Checks that the given editor texture use the correct import settings, + and applies them if they're incorrect. + + + + + Returns TRUE if setup is required + + + + + Returns TRUE if the file/directory at the given path exists. + + Path, relative to Unity's project folder + + + + + Converts the given project-relative path to a full path, + with backward (\) slashes). + + + + + Converts the given full path to a path usable with AssetDatabase methods + (relative to Unity's project folder, and with the correct Unity forward (/) slashes). + + + + + Connects to a asset. + If the asset already exists at the given path, loads it and returns it. + Otherwise, either returns NULL or automatically creates it before loading and returning it + (depending on the given parameters). + + Asset type + File path (relative to Unity's project folder) + If TRUE and the requested asset doesn't exist, forces its creation + + + + Full path for the given loaded assembly, assembly file included + + + + + Adds the given global define if it's not already present + + + + + Removes the given global define if it's present + + + + + Returns TRUE if the given global define is present in all the + or only in the given , depending on passed parameters. + + + to use. Leave NULL to check in all of them. + + + + Not used as menu item anymore, but as a utility function + + + + Sets the modules bool values to the current defines state + + + Refreshes the enabled state of all defines + + + Applies the guiEnabled value state to each define, adding or removing them based on that + + + Removes all DOTween defines including the ones for external assets + + + Removes all legacy defines + + + Removes the define if present + + + Adds the define if it's not already present + + + Full major version + first minor version (ex: 2018.1f) + + + Major version + + + First minor version (ex: in 2018.1 it would be 1) + + + diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML.meta b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML.meta new file mode 100644 index 0000000..7cec113 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML.meta @@ -0,0 +1,4 @@ +fileFormatVersion: 2 +guid: 2e2c6224d345d9249acfa6e8ef40bb2d +TextScriptImporter: + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll b/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll new file mode 100644 index 0000000000000000000000000000000000000000..3c804aa0ad3f6e371820e97feb19960b2184a56c GIT binary patch literal 66560 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 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..50aa010 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: b766d08851589514b97afb23c6f30a70 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs new file mode 100644 index 0000000..4eb7b77 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs @@ -0,0 +1,146 @@ +using UnityEngine; + +#if DOTWEEN_EPO || EPO_DOTWEEN // MODULE_MARKER + +using EPOOutline; +using DG.Tweening.Plugins.Options; +using DG.Tweening; +using DG.Tweening.Core; + +namespace DG.Tweening +{ + public static class DOTweenModuleEPOOutline + { + public static int DOKill(this SerializedPass target, bool complete) + { + return DOTween.Kill(target, complete); + } + + public static TweenerCore DOFloat(this SerializedPass target, string propertyName, float endValue, float duration) + { + var tweener = DOTween.To(() => target.GetFloat(propertyName), x => target.SetFloat(propertyName, x), endValue, duration); + tweener.SetOptions(true).SetTarget(target); + return tweener; + } + + public static TweenerCore DOFade(this SerializedPass target, string propertyName, float endValue, float duration) + { + var tweener = DOTween.ToAlpha(() => target.GetColor(propertyName), x => target.SetColor(propertyName, x), endValue, duration); + tweener.SetOptions(true).SetTarget(target); + return tweener; + } + + public static TweenerCore DOColor(this SerializedPass target, string propertyName, Color endValue, float duration) + { + var tweener = DOTween.To(() => target.GetColor(propertyName), x => target.SetColor(propertyName, x), endValue, duration); + tweener.SetOptions(false).SetTarget(target); + return tweener; + } + + public static TweenerCore DOVector(this SerializedPass target, string propertyName, Vector4 endValue, float duration) + { + var tweener = DOTween.To(() => target.GetVector(propertyName), x => target.SetVector(propertyName, x), endValue, duration); + tweener.SetOptions(false).SetTarget(target); + return tweener; + } + + public static TweenerCore DOFloat(this SerializedPass target, int propertyId, float endValue, float duration) + { + var tweener = DOTween.To(() => target.GetFloat(propertyId), x => target.SetFloat(propertyId, x), endValue, duration); + tweener.SetOptions(true).SetTarget(target); + return tweener; + } + + public static TweenerCore DOFade(this SerializedPass target, int propertyId, float endValue, float duration) + { + var tweener = DOTween.ToAlpha(() => target.GetColor(propertyId), x => target.SetColor(propertyId, x), endValue, duration); + tweener.SetOptions(true).SetTarget(target); + return tweener; + } + + public static TweenerCore DOColor(this SerializedPass target, int propertyId, Color endValue, float duration) + { + var tweener = DOTween.To(() => target.GetColor(propertyId), x => target.SetColor(propertyId, x), endValue, duration); + tweener.SetOptions(false).SetTarget(target); + return tweener; + } + + public static TweenerCore DOVector(this SerializedPass target, int propertyId, Vector4 endValue, float duration) + { + var tweener = DOTween.To(() => target.GetVector(propertyId), x => target.SetVector(propertyId, x), endValue, duration); + tweener.SetOptions(false).SetTarget(target); + return tweener; + } + + public static int DOKill(this Outlinable.OutlineProperties target, bool complete = false) + { + return DOTween.Kill(target, complete); + } + + public static int DOKill(this Outliner target, bool complete = false) + { + return DOTween.Kill(target, complete); + } + + /// + /// Controls the alpha (transparency) of the outline + /// + public static TweenerCore DOFade(this Outlinable.OutlineProperties target, float endValue, float duration) + { + var tweener = DOTween.ToAlpha(() => target.Color, x => target.Color = x, endValue, duration); + tweener.SetOptions(true).SetTarget(target); + return tweener; + } + + /// + /// Controls the color of the outline + /// + public static TweenerCore DOColor(this Outlinable.OutlineProperties target, Color endValue, float duration) + { + var tweener = DOTween.To(() => target.Color, x => target.Color = x, endValue, duration); + tweener.SetOptions(false).SetTarget(target); + return tweener; + } + + /// + /// Controls the amount of blur applied to the outline + /// + public static TweenerCore DOBlurShift(this Outlinable.OutlineProperties target, float endValue, float duration, bool snapping = false) + { + var tweener = DOTween.To(() => target.BlurShift, x => target.BlurShift = x, endValue, duration); + tweener.SetOptions(snapping).SetTarget(target); + return tweener; + } + + /// + /// Controls the amount of blur applied to the outline + /// + public static TweenerCore DOBlurShift(this Outliner target, float endValue, float duration, bool snapping = false) + { + var tweener = DOTween.To(() => target.BlurShift, x => target.BlurShift = x, endValue, duration); + tweener.SetOptions(snapping).SetTarget(target); + return tweener; + } + + /// + /// Controls the amount of dilation applied to the outline + /// + public static TweenerCore DODilateShift(this Outlinable.OutlineProperties target, float endValue, float duration, bool snapping = false) + { + var tweener = DOTween.To(() => target.DilateShift, x => target.DilateShift = x, endValue, duration); + tweener.SetOptions(snapping).SetTarget(target); + return tweener; + } + + /// + /// Controls the amount of dilation applied to the outline + /// + public static TweenerCore DODilateShift(this Outliner target, float endValue, float duration, bool snapping = false) + { + var tweener = DOTween.To(() => target.DilateShift, x => target.DilateShift = x, endValue, duration); + tweener.SetOptions(snapping).SetTarget(target); + return tweener; + } + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs.meta new file mode 100644 index 0000000..4b8991f --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleEPOOutline.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: e944529dcaee98f4e9498d80e541d93e +timeCreated: 1602593330 +licenseType: Store +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs new file mode 100644 index 0000000..51786e3 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs @@ -0,0 +1,216 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +#if !DOTWEEN_NOPHYSICS // MODULE_MARKER +using System; +using DG.Tweening.Core; +using DG.Tweening.Core.Enums; +using DG.Tweening.Plugins; +using DG.Tweening.Plugins.Core.PathCore; +using DG.Tweening.Plugins.Options; +using UnityEngine; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModulePhysics + { + #region Shortcuts + + #region Rigidbody + + /// Tweens a Rigidbody's position to the given value. + /// Also stores the rigidbody as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMove(this Rigidbody target, Vector3 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody's X position to the given value. + /// Also stores the rigidbody as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveX(this Rigidbody target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue, 0, 0), duration); + t.SetOptions(AxisConstraint.X, snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody's Y position to the given value. + /// Also stores the rigidbody as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveY(this Rigidbody target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, endValue, 0), duration); + t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody's Z position to the given value. + /// Also stores the rigidbody as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveZ(this Rigidbody target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, 0, endValue), duration); + t.SetOptions(AxisConstraint.Z, snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody's rotation to the given value. + /// Also stores the rigidbody as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// Rotation mode + public static TweenerCore DORotate(this Rigidbody target, Vector3 endValue, float duration, RotateMode mode = RotateMode.Fast) + { + TweenerCore t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration); + t.SetTarget(target); + t.plugOptions.rotateMode = mode; + return t; + } + + /// Tweens a Rigidbody's rotation so that it will look towards the given position. + /// Also stores the rigidbody as the tween's target so it can be used for filtered operations + /// The position to look atThe duration of the tween + /// Eventual axis constraint for the rotation + /// The vector that defines in which direction up is (default: Vector3.up) + public static TweenerCore DOLookAt(this Rigidbody target, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3? up = null) + { + TweenerCore t = DOTween.To(() => target.rotation, target.MoveRotation, towards, duration) + .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetLookAt); + t.plugOptions.axisConstraint = axisConstraint; + t.plugOptions.up = (up == null) ? Vector3.up : (Vector3)up; + return t; + } + + #region Special + + /// Tweens a Rigidbody's position to the given value, while also applying a jump effect along the Y axis. + /// Returns a Sequence instead of a Tweener. + /// Also stores the Rigidbody as the tween's target so it can be used for filtered operations + /// The end value to reach + /// Power of the jump (the max height of the jump is represented by this plus the final Y offset) + /// Total number of jumps + /// The duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static Sequence DOJump(this Rigidbody target, Vector3 endValue, float jumpPower, int numJumps, float duration, bool snapping = false) + { + if (numJumps < 1) numJumps = 1; + float startPosY = 0; + float offsetY = -1; + bool offsetYSet = false; + Sequence s = DOTween.Sequence(); + Tween yTween = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, jumpPower, 0), duration / (numJumps * 2)) + .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative() + .SetLoops(numJumps * 2, LoopType.Yoyo) + .OnStart(() => startPosY = target.position.y); + s.Append(DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue.x, 0, 0), duration) + .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear) + ).Join(DOTween.To(() => target.position, target.MovePosition, new Vector3(0, 0, endValue.z), duration) + .SetOptions(AxisConstraint.Z, snapping).SetEase(Ease.Linear) + ).Join(yTween) + .SetTarget(target).SetEase(DOTween.defaultEaseType); + yTween.OnUpdate(() => { + if (!offsetYSet) { + offsetYSet = true; + offsetY = s.isRelative ? endValue.y : endValue.y - startPosY; + } + Vector3 pos = target.position; + pos.y += DOVirtual.EasedValue(0, offsetY, yTween.ElapsedPercentage(), Ease.OutQuad); + target.MovePosition(pos); + }); + return s; + } + + /// Tweens a Rigidbody's position through the given path waypoints, using the chosen path algorithm. + /// Also stores the Rigidbody as the tween's target so it can be used for filtered operations. + /// NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened. + /// BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug). + /// If you plan to publish there you should use a regular transform.DOPath. + /// The waypoints to go through + /// The duration of the tween + /// The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points) + /// The path mode: 3D, side-scroller 2D, top-down 2D + /// The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved paths but are more expensive. + /// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints + /// The color of the path (shown when gizmos are active in the Play panel and the tween is running) + public static TweenerCore DOPath( + this Rigidbody target, Vector3[] path, float duration, PathType pathType = PathType.Linear, + PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null + ) + { + if (resolution < 1) resolution = 1; + TweenerCore t = DOTween.To(PathPlugin.Get(), () => target.position, target.MovePosition, new Path(pathType, path, resolution, gizmoColor), duration) + .SetTarget(target).SetUpdate(UpdateType.Fixed); + + t.plugOptions.isRigidbody = true; + t.plugOptions.mode = pathMode; + return t; + } + /// Tweens a Rigidbody's localPosition through the given path waypoints, using the chosen path algorithm. + /// Also stores the Rigidbody as the tween's target so it can be used for filtered operations + /// NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened. + /// BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug). + /// If you plan to publish there you should use a regular transform.DOLocalPath. + /// The waypoint to go through + /// The duration of the tween + /// The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points) + /// The path mode: 3D, side-scroller 2D, top-down 2D + /// The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive. + /// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints + /// The color of the path (shown when gizmos are active in the Play panel and the tween is running) + public static TweenerCore DOLocalPath( + this Rigidbody target, Vector3[] path, float duration, PathType pathType = PathType.Linear, + PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null + ) + { + if (resolution < 1) resolution = 1; + Transform trans = target.transform; + TweenerCore t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), new Path(pathType, path, resolution, gizmoColor), duration) + .SetTarget(target).SetUpdate(UpdateType.Fixed); + + t.plugOptions.isRigidbody = true; + t.plugOptions.mode = pathMode; + t.plugOptions.useLocalPosition = true; + return t; + } + // Used by path editor when creating the actual tween, so it can pass a pre-compiled path + internal static TweenerCore DOPath( + this Rigidbody target, Path path, float duration, PathMode pathMode = PathMode.Full3D + ) + { + TweenerCore t = DOTween.To(PathPlugin.Get(), () => target.position, target.MovePosition, path, duration) + .SetTarget(target); + + t.plugOptions.isRigidbody = true; + t.plugOptions.mode = pathMode; + return t; + } + internal static TweenerCore DOLocalPath( + this Rigidbody target, Path path, float duration, PathMode pathMode = PathMode.Full3D + ) + { + Transform trans = target.transform; + TweenerCore t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), path, duration) + .SetTarget(target); + + t.plugOptions.isRigidbody = true; + t.plugOptions.mode = pathMode; + t.plugOptions.useLocalPosition = true; + return t; + } + + #endregion + + #endregion + + #endregion + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs.meta new file mode 100644 index 0000000..0ce0d75 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: dae9aa560b4242648a3affa2bfabc365 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs new file mode 100644 index 0000000..045eccc --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs @@ -0,0 +1,193 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +#if !DOTWEEN_NOPHYSICS2D // MODULE_MARKER +using System; +using DG.Tweening.Core; +using DG.Tweening.Plugins; +using DG.Tweening.Plugins.Core.PathCore; +using DG.Tweening.Plugins.Options; +using UnityEngine; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModulePhysics2D + { + #region Shortcuts + + #region Rigidbody2D Shortcuts + + /// Tweens a Rigidbody2D's position to the given value. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMove(this Rigidbody2D target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody2D's X position to the given value. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveX(this Rigidbody2D target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, new Vector2(endValue, 0), duration); + t.SetOptions(AxisConstraint.X, snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody2D's Y position to the given value. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveY(this Rigidbody2D target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.position, target.MovePosition, new Vector2(0, endValue), duration); + t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target); + return t; + } + + /// Tweens a Rigidbody2D's rotation to the given value. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DORotate(this Rigidbody2D target, float endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration); + t.SetTarget(target); + return t; + } + + #region Special + + /// Tweens a Rigidbody2D's position to the given value, while also applying a jump effect along the Y axis. + /// Returns a Sequence instead of a Tweener. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations. + /// IMPORTANT: a rigidbody2D can't be animated in a jump arc using MovePosition, so the tween will directly set the position + /// The end value to reach + /// Power of the jump (the max height of the jump is represented by this plus the final Y offset) + /// Total number of jumps + /// The duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static Sequence DOJump(this Rigidbody2D target, Vector2 endValue, float jumpPower, int numJumps, float duration, bool snapping = false) + { + if (numJumps < 1) numJumps = 1; + float startPosY = 0; + float offsetY = -1; + bool offsetYSet = false; + Sequence s = DOTween.Sequence(); + Tween yTween = DOTween.To(() => target.position, x => target.position = x, new Vector2(0, jumpPower), duration / (numJumps * 2)) + .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative() + .SetLoops(numJumps * 2, LoopType.Yoyo) + .OnStart(() => startPosY = target.position.y); + s.Append(DOTween.To(() => target.position, x => target.position = x, new Vector2(endValue.x, 0), duration) + .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear) + ).Join(yTween) + .SetTarget(target).SetEase(DOTween.defaultEaseType); + yTween.OnUpdate(() => { + if (!offsetYSet) { + offsetYSet = true; + offsetY = s.isRelative ? endValue.y : endValue.y - startPosY; + } + Vector3 pos = target.position; + pos.y += DOVirtual.EasedValue(0, offsetY, yTween.ElapsedPercentage(), Ease.OutQuad); + target.MovePosition(pos); + }); + return s; + } + + /// Tweens a Rigidbody2D's position through the given path waypoints, using the chosen path algorithm. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations. + /// NOTE: to tween a Rigidbody2D correctly it should be set to kinematic at least while being tweened. + /// BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug). + /// If you plan to publish there you should use a regular transform.DOPath. + /// The waypoints to go through + /// The duration of the tween + /// The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points) + /// The path mode: 3D, side-scroller 2D, top-down 2D + /// The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved paths but are more expensive. + /// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints + /// The color of the path (shown when gizmos are active in the Play panel and the tween is running) + public static TweenerCore DOPath( + this Rigidbody2D target, Vector2[] path, float duration, PathType pathType = PathType.Linear, + PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null + ) + { + if (resolution < 1) resolution = 1; + int len = path.Length; + Vector3[] path3D = new Vector3[len]; + for (int i = 0; i < len; ++i) path3D[i] = path[i]; + TweenerCore t = DOTween.To(PathPlugin.Get(), () => target.position, x => target.MovePosition(x), new Path(pathType, path3D, resolution, gizmoColor), duration) + .SetTarget(target).SetUpdate(UpdateType.Fixed); + + t.plugOptions.isRigidbody2D = true; + t.plugOptions.mode = pathMode; + return t; + } + /// Tweens a Rigidbody2D's localPosition through the given path waypoints, using the chosen path algorithm. + /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations + /// NOTE: to tween a Rigidbody2D correctly it should be set to kinematic at least while being tweened. + /// BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug). + /// If you plan to publish there you should use a regular transform.DOLocalPath. + /// The waypoint to go through + /// The duration of the tween + /// The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points) + /// The path mode: 3D, side-scroller 2D, top-down 2D + /// The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive. + /// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints + /// The color of the path (shown when gizmos are active in the Play panel and the tween is running) + public static TweenerCore DOLocalPath( + this Rigidbody2D target, Vector2[] path, float duration, PathType pathType = PathType.Linear, + PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null + ) + { + if (resolution < 1) resolution = 1; + int len = path.Length; + Vector3[] path3D = new Vector3[len]; + for (int i = 0; i < len; ++i) path3D[i] = path[i]; + Transform trans = target.transform; + TweenerCore t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), new Path(pathType, path3D, resolution, gizmoColor), duration) + .SetTarget(target).SetUpdate(UpdateType.Fixed); + + t.plugOptions.isRigidbody2D = true; + t.plugOptions.mode = pathMode; + t.plugOptions.useLocalPosition = true; + return t; + } + // Used by path editor when creating the actual tween, so it can pass a pre-compiled path + internal static TweenerCore DOPath( + this Rigidbody2D target, Path path, float duration, PathMode pathMode = PathMode.Full3D + ) + { + TweenerCore t = DOTween.To(PathPlugin.Get(), () => target.position, x => target.MovePosition(x), path, duration) + .SetTarget(target); + + t.plugOptions.isRigidbody2D = true; + t.plugOptions.mode = pathMode; + return t; + } + internal static TweenerCore DOLocalPath( + this Rigidbody2D target, Path path, float duration, PathMode pathMode = PathMode.Full3D + ) + { + Transform trans = target.transform; + TweenerCore t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), path, duration) + .SetTarget(target); + + t.plugOptions.isRigidbody2D = true; + t.plugOptions.mode = pathMode; + t.plugOptions.useLocalPosition = true; + return t; + } + + #endregion + + #endregion + + #endregion + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs.meta new file mode 100644 index 0000000..ca9ed29 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 230fe34542e175245ba74b4659dae700 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs new file mode 100644 index 0000000..4d4a0c4 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs @@ -0,0 +1,93 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +#if !DOTWEEN_NOSPRITES // MODULE_MARKER +using System; +using UnityEngine; +using DG.Tweening.Core; +using DG.Tweening.Plugins.Options; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModuleSprite + { + #region Shortcuts + + #region SpriteRenderer + + /// Tweens a SpriteRenderer's color to the given value. + /// Also stores the spriteRenderer as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOColor(this SpriteRenderer target, Color endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a Material's alpha color to the given value. + /// Also stores the spriteRenderer as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOFade(this SpriteRenderer target, float endValue, float duration) + { + TweenerCore t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a SpriteRenderer's color using the given gradient + /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener). + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The gradient to useThe duration of the tween + public static Sequence DOGradientColor(this SpriteRenderer target, Gradient gradient, float duration) + { + Sequence s = DOTween.Sequence(); + GradientColorKey[] colors = gradient.colorKeys; + int len = colors.Length; + for (int i = 0; i < len; ++i) { + GradientColorKey c = colors[i]; + if (i == 0 && c.time <= 0) { + target.color = c.color; + continue; + } + float colorDuration = i == len - 1 + ? duration - s.Duration(false) // Verifies that total duration is correct + : duration * (i == 0 ? c.time : c.time - colors[i - 1].time); + s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear)); + } + s.SetTarget(target); + return s; + } + + #endregion + + #region Blendables + + #region SpriteRenderer + + /// Tweens a SpriteRenderer's color to the given value, + /// in a way that allows other DOBlendableColor tweens to work together on the same target, + /// instead than fight each other as multiple DOColor would do. + /// Also stores the SpriteRenderer as the tween's target so it can be used for filtered operations + /// The value to tween toThe duration of the tween + public static Tweener DOBlendableColor(this SpriteRenderer target, Color endValue, float duration) + { + endValue = endValue - target.color; + Color to = new Color(0, 0, 0, 0); + return DOTween.To(() => to, x => { + Color diff = x - to; + to = x; + target.color += diff; + }, endValue, duration) + .Blendable().SetTarget(target); + } + + #endregion + + #endregion + + #endregion + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs.meta new file mode 100644 index 0000000..a0c67c4 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 188918ab119d93148aa0de59ccf5286b +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs new file mode 100644 index 0000000..4708449 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs @@ -0,0 +1,662 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +#if !DOTWEEN_NOUI // MODULE_MARKER + +using System; +using System.Globalization; +using UnityEngine; +using UnityEngine.UI; +using DG.Tweening.Core; +using DG.Tweening.Core.Enums; +using DG.Tweening.Plugins; +using DG.Tweening.Plugins.Options; +using Outline = UnityEngine.UI.Outline; +using Text = UnityEngine.UI.Text; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModuleUI + { + #region Shortcuts + + #region CanvasGroup + + /// Tweens a CanvasGroup's alpha color to the given value. + /// Also stores the canvasGroup as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOFade(this CanvasGroup target, float endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.alpha, x => target.alpha = x, endValue, duration); + t.SetTarget(target); + return t; + } + + #endregion + + #region Graphic + + /// Tweens an Graphic's color to the given value. + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOColor(this Graphic target, Color endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens an Graphic's alpha color to the given value. + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOFade(this Graphic target, float endValue, float duration) + { + TweenerCore t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + #endregion + + #region Image + + /// Tweens an Image's color to the given value. + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOColor(this Image target, Color endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens an Image's alpha color to the given value. + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOFade(this Image target, float endValue, float duration) + { + TweenerCore t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens an Image's fillAmount to the given value. + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The end value to reach (0 to 1)The duration of the tween + public static TweenerCore DOFillAmount(this Image target, float endValue, float duration) + { + if (endValue > 1) endValue = 1; + else if (endValue < 0) endValue = 0; + TweenerCore t = DOTween.To(() => target.fillAmount, x => target.fillAmount = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens an Image's colors using the given gradient + /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener). + /// Also stores the image as the tween's target so it can be used for filtered operations + /// The gradient to useThe duration of the tween + public static Sequence DOGradientColor(this Image target, Gradient gradient, float duration) + { + Sequence s = DOTween.Sequence(); + GradientColorKey[] colors = gradient.colorKeys; + int len = colors.Length; + for (int i = 0; i < len; ++i) { + GradientColorKey c = colors[i]; + if (i == 0 && c.time <= 0) { + target.color = c.color; + continue; + } + float colorDuration = i == len - 1 + ? duration - s.Duration(false) // Verifies that total duration is correct + : duration * (i == 0 ? c.time : c.time - colors[i - 1].time); + s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear)); + } + s.SetTarget(target); + return s; + } + + #endregion + + #region LayoutElement + + /// Tweens an LayoutElement's flexibleWidth/Height to the given value. + /// Also stores the LayoutElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOFlexibleSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => new Vector2(target.flexibleWidth, target.flexibleHeight), x => { + target.flexibleWidth = x.x; + target.flexibleHeight = x.y; + }, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Tweens an LayoutElement's minWidth/Height to the given value. + /// Also stores the LayoutElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMinSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => new Vector2(target.minWidth, target.minHeight), x => { + target.minWidth = x.x; + target.minHeight = x.y; + }, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Tweens an LayoutElement's preferredWidth/Height to the given value. + /// Also stores the LayoutElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOPreferredSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => new Vector2(target.preferredWidth, target.preferredHeight), x => { + target.preferredWidth = x.x; + target.preferredHeight = x.y; + }, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + #endregion + + #region Outline + + /// Tweens a Outline's effectColor to the given value. + /// Also stores the Outline as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOColor(this Outline target, Color endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.effectColor, x => target.effectColor = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a Outline's effectColor alpha to the given value. + /// Also stores the Outline as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOFade(this Outline target, float endValue, float duration) + { + TweenerCore t = DOTween.ToAlpha(() => target.effectColor, x => target.effectColor = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a Outline's effectDistance to the given value. + /// Also stores the Outline as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOScale(this Outline target, Vector2 endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.effectDistance, x => target.effectDistance = x, endValue, duration); + t.SetTarget(target); + return t; + } + + #endregion + + #region RectTransform + + /// Tweens a RectTransform's anchoredPosition to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPos(this RectTransform target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + /// Tweens a RectTransform's anchoredPosition X to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPosX(this RectTransform target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(endValue, 0), duration); + t.SetOptions(AxisConstraint.X, snapping).SetTarget(target); + return t; + } + /// Tweens a RectTransform's anchoredPosition Y to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPosY(this RectTransform target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(0, endValue), duration); + t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target); + return t; + } + + /// Tweens a RectTransform's anchoredPosition3D to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPos3D(this RectTransform target, Vector3 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + /// Tweens a RectTransform's anchoredPosition3D X to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPos3DX(this RectTransform target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(endValue, 0, 0), duration); + t.SetOptions(AxisConstraint.X, snapping).SetTarget(target); + return t; + } + /// Tweens a RectTransform's anchoredPosition3D Y to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPos3DY(this RectTransform target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(0, endValue, 0), duration); + t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target); + return t; + } + /// Tweens a RectTransform's anchoredPosition3D Z to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorPos3DZ(this RectTransform target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(0, 0, endValue), duration); + t.SetOptions(AxisConstraint.Z, snapping).SetTarget(target); + return t; + } + + /// Tweens a RectTransform's anchorMax to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorMax(this RectTransform target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchorMax, x => target.anchorMax = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Tweens a RectTransform's anchorMin to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOAnchorMin(this RectTransform target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.anchorMin, x => target.anchorMin = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Tweens a RectTransform's pivot to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOPivot(this RectTransform target, Vector2 endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.pivot, x => target.pivot = x, endValue, duration); + t.SetTarget(target); + return t; + } + /// Tweens a RectTransform's pivot X to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOPivotX(this RectTransform target, float endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.pivot, x => target.pivot = x, new Vector2(endValue, 0), duration); + t.SetOptions(AxisConstraint.X).SetTarget(target); + return t; + } + /// Tweens a RectTransform's pivot Y to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOPivotY(this RectTransform target, float endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.pivot, x => target.pivot = x, new Vector2(0, endValue), duration); + t.SetOptions(AxisConstraint.Y).SetTarget(target); + return t; + } + + /// Tweens a RectTransform's sizeDelta to the given value. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOSizeDelta(this RectTransform target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.sizeDelta, x => target.sizeDelta = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + /// Punches a RectTransform's anchoredPosition towards the given direction and then back to the starting one + /// as if it was connected to the starting position via an elastic. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The direction and strength of the punch (added to the RectTransform's current position) + /// The duration of the tween + /// Indicates how much will the punch vibrate + /// Represents how much (0 to 1) the vector will go beyond the starting position when bouncing backwards. + /// 1 creates a full oscillation between the punch direction and the opposite direction, + /// while 0 oscillates only between the punch and the start position + /// If TRUE the tween will smoothly snap all values to integers + public static Tweener DOPunchAnchorPos(this RectTransform target, Vector2 punch, float duration, int vibrato = 10, float elasticity = 1, bool snapping = false) + { + return DOTween.Punch(() => target.anchoredPosition, x => target.anchoredPosition = x, punch, duration, vibrato, elasticity) + .SetTarget(target).SetOptions(snapping); + } + + /// Shakes a RectTransform's anchoredPosition with the given values. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The duration of the tween + /// The shake strength + /// Indicates how much will the shake vibrate + /// Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + /// Setting it to 0 will shake along a single direction. + /// If TRUE the tween will smoothly snap all values to integers + /// If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + /// Randomness mode + public static Tweener DOShakeAnchorPos(this RectTransform target, float duration, float strength = 100, int vibrato = 10, float randomness = 90, bool snapping = false, bool fadeOut = true, ShakeRandomnessMode randomnessMode = ShakeRandomnessMode.Full) + { + return DOTween.Shake(() => target.anchoredPosition, x => target.anchoredPosition = x, duration, strength, vibrato, randomness, true, fadeOut, randomnessMode) + .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetShake).SetOptions(snapping); + } + /// Shakes a RectTransform's anchoredPosition with the given values. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The duration of the tween + /// The shake strength on each axis + /// Indicates how much will the shake vibrate + /// Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). + /// Setting it to 0 will shake along a single direction. + /// If TRUE the tween will smoothly snap all values to integers + /// If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not + /// Randomness mode + public static Tweener DOShakeAnchorPos(this RectTransform target, float duration, Vector2 strength, int vibrato = 10, float randomness = 90, bool snapping = false, bool fadeOut = true, ShakeRandomnessMode randomnessMode = ShakeRandomnessMode.Full) + { + return DOTween.Shake(() => target.anchoredPosition, x => target.anchoredPosition = x, duration, strength, vibrato, randomness, fadeOut, randomnessMode) + .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetShake).SetOptions(snapping); + } + + #region Special + + /// Tweens a RectTransform's anchoredPosition to the given value, while also applying a jump effect along the Y axis. + /// Returns a Sequence instead of a Tweener. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations + /// The end value to reach + /// Power of the jump (the max height of the jump is represented by this plus the final Y offset) + /// Total number of jumps + /// The duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static Sequence DOJumpAnchorPos(this RectTransform target, Vector2 endValue, float jumpPower, int numJumps, float duration, bool snapping = false) + { + if (numJumps < 1) numJumps = 1; + float startPosY = 0; + float offsetY = -1; + bool offsetYSet = false; + + // Separate Y Tween so we can elaborate elapsedPercentage on that insted of on the Sequence + // (in case users add a delay or other elements to the Sequence) + Sequence s = DOTween.Sequence(); + Tween yTween = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(0, jumpPower), duration / (numJumps * 2)) + .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative() + .SetLoops(numJumps * 2, LoopType.Yoyo) + .OnStart(()=> startPosY = target.anchoredPosition.y); + s.Append(DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(endValue.x, 0), duration) + .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear) + ).Join(yTween) + .SetTarget(target).SetEase(DOTween.defaultEaseType); + s.OnUpdate(() => { + if (!offsetYSet) { + offsetYSet = true; + offsetY = s.isRelative ? endValue.y : endValue.y - startPosY; + } + Vector2 pos = target.anchoredPosition; + pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad); + target.anchoredPosition = pos; + }); + return s; + } + + #endregion + + #endregion + + #region ScrollRect + + /// Tweens a ScrollRect's horizontal/verticalNormalizedPosition to the given value. + /// Also stores the ScrollRect as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static Tweener DONormalizedPos(this ScrollRect target, Vector2 endValue, float duration, bool snapping = false) + { + return DOTween.To(() => new Vector2(target.horizontalNormalizedPosition, target.verticalNormalizedPosition), + x => { + target.horizontalNormalizedPosition = x.x; + target.verticalNormalizedPosition = x.y; + }, endValue, duration) + .SetOptions(snapping).SetTarget(target); + } + /// Tweens a ScrollRect's horizontalNormalizedPosition to the given value. + /// Also stores the ScrollRect as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static Tweener DOHorizontalNormalizedPos(this ScrollRect target, float endValue, float duration, bool snapping = false) + { + return DOTween.To(() => target.horizontalNormalizedPosition, x => target.horizontalNormalizedPosition = x, endValue, duration) + .SetOptions(snapping).SetTarget(target); + } + /// Tweens a ScrollRect's verticalNormalizedPosition to the given value. + /// Also stores the ScrollRect as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static Tweener DOVerticalNormalizedPos(this ScrollRect target, float endValue, float duration, bool snapping = false) + { + return DOTween.To(() => target.verticalNormalizedPosition, x => target.verticalNormalizedPosition = x, endValue, duration) + .SetOptions(snapping).SetTarget(target); + } + + #endregion + + #region Slider + + /// Tweens a Slider's value to the given value. + /// Also stores the Slider as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOValue(this Slider target, float endValue, float duration, bool snapping = false) + { + TweenerCore t = DOTween.To(() => target.value, x => target.value = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + + #endregion + + #region Text + + /// Tweens a Text's color to the given value. + /// Also stores the Text as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOColor(this Text target, Color endValue, float duration) + { + TweenerCore t = DOTween.To(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// + /// Tweens a Text's text from one integer to another, with options for thousands separators + /// + /// The value to start from + /// The end value to reach + /// The duration of the tween + /// If TRUE (default) also adds thousands separators + /// The to use (InvariantCulture if NULL) + public static TweenerCore DOCounter( + this Text target, int fromValue, int endValue, float duration, bool addThousandsSeparator = true, CultureInfo culture = null + ){ + int v = fromValue; + CultureInfo cInfo = !addThousandsSeparator ? null : culture ?? CultureInfo.InvariantCulture; + TweenerCore t = DOTween.To(() => v, x => { + v = x; + target.text = addThousandsSeparator + ? v.ToString("N0", cInfo) + : v.ToString(); + }, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a Text's alpha color to the given value. + /// Also stores the Text as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOFade(this Text target, float endValue, float duration) + { + TweenerCore t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration); + t.SetTarget(target); + return t; + } + + /// Tweens a Text's text to the given value. + /// Also stores the Text as the tween's target so it can be used for filtered operations + /// The end string to tween toThe duration of the tween + /// If TRUE (default), rich text will be interpreted correctly while animated, + /// otherwise all tags will be considered as normal text + /// The type of scramble mode to use, if any + /// A string containing the characters to use for scrambling. + /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters. + /// Leave it to NULL (default) to use default ones + public static TweenerCore DOText(this Text target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null) + { + if (endValue == null) { + if (Debugger.logPriority > 0) Debugger.LogWarning("You can't pass a NULL string to DOText: an empty string will be used instead to avoid errors"); + endValue = ""; + } + TweenerCore t = DOTween.To(() => target.text, x => target.text = x, endValue, duration); + t.SetOptions(richTextEnabled, scrambleMode, scrambleChars) + .SetTarget(target); + return t; + } + + #endregion + + #region Blendables + + #region Graphic + + /// Tweens a Graphic's color to the given value, + /// in a way that allows other DOBlendableColor tweens to work together on the same target, + /// instead than fight each other as multiple DOColor would do. + /// Also stores the Graphic as the tween's target so it can be used for filtered operations + /// The value to tween toThe duration of the tween + public static Tweener DOBlendableColor(this Graphic target, Color endValue, float duration) + { + endValue = endValue - target.color; + Color to = new Color(0, 0, 0, 0); + return DOTween.To(() => to, x => { + Color diff = x - to; + to = x; + target.color += diff; + }, endValue, duration) + .Blendable().SetTarget(target); + } + + #endregion + + #region Image + + /// Tweens a Image's color to the given value, + /// in a way that allows other DOBlendableColor tweens to work together on the same target, + /// instead than fight each other as multiple DOColor would do. + /// Also stores the Image as the tween's target so it can be used for filtered operations + /// The value to tween toThe duration of the tween + public static Tweener DOBlendableColor(this Image target, Color endValue, float duration) + { + endValue = endValue - target.color; + Color to = new Color(0, 0, 0, 0); + return DOTween.To(() => to, x => { + Color diff = x - to; + to = x; + target.color += diff; + }, endValue, duration) + .Blendable().SetTarget(target); + } + + #endregion + + #region Text + + /// Tweens a Text's color BY the given value, + /// in a way that allows other DOBlendableColor tweens to work together on the same target, + /// instead than fight each other as multiple DOColor would do. + /// Also stores the Text as the tween's target so it can be used for filtered operations + /// The value to tween toThe duration of the tween + public static Tweener DOBlendableColor(this Text target, Color endValue, float duration) + { + endValue = endValue - target.color; + Color to = new Color(0, 0, 0, 0); + return DOTween.To(() => to, x => { + Color diff = x - to; + to = x; + target.color += diff; + }, endValue, duration) + .Blendable().SetTarget(target); + } + + #endregion + + #endregion + + #region Shapes + + /// Tweens a RectTransform's anchoredPosition so that it draws a circle around the given center. + /// Also stores the RectTransform as the tween's target so it can be used for filtered operations. + /// IMPORTANT: SetFrom(value) requires a instead of a float, where the X property represents the "from degrees value" + /// Circle-center/pivot around which to rotate (in UI anchoredPosition coordinates) + /// The end value degrees to reach (to rotate counter-clockwise pass a negative value) + /// The duration of the tween + /// If TRUE the coordinates will be considered as relative to the target's current anchoredPosition + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOShapeCircle( + this RectTransform target, Vector2 center, float endValueDegrees, float duration, bool relativeCenter = false, bool snapping = false + ) + { + TweenerCore t = DOTween.To( + CirclePlugin.Get(), () => target.anchoredPosition, x => target.anchoredPosition = x, center, duration + ); + t.SetOptions(endValueDegrees, relativeCenter, snapping).SetTarget(target); + return t; + } + + #endregion + + #endregion + + // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ + // ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████ + // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ + + public static class Utils + { + /// + /// Converts the anchoredPosition of the first RectTransform to the second RectTransform, + /// taking into consideration offset, anchors and pivot, and returns the new anchoredPosition + /// + public static Vector2 SwitchToRectTransform(RectTransform from, RectTransform to) + { + Vector2 localPoint; + Vector2 fromPivotDerivedOffset = new Vector2(from.rect.width * 0.5f + from.rect.xMin, from.rect.height * 0.5f + from.rect.yMin); + Vector2 screenP = RectTransformUtility.WorldToScreenPoint(null, from.position); + screenP += fromPivotDerivedOffset; + RectTransformUtility.ScreenPointToLocalPointInRectangle(to, screenP, null, out localPoint); + Vector2 pivotDerivedOffset = new Vector2(to.rect.width * 0.5f + to.rect.xMin, to.rect.height * 0.5f + to.rect.yMin); + return to.anchoredPosition + localPoint - pivotDerivedOffset; + } + } + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs.meta new file mode 100644 index 0000000..60d55ef --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: a060394c03331a64392db53a10e7f2d1 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs new file mode 100644 index 0000000..7f47da2 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs @@ -0,0 +1,113 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2026/01/08 + +#if DOTWEEN_UITOOLKIT && UNITY_2021_3_OR_NEWER // MODULE_MARKER + +using UnityEngine; +using UnityEngine.UIElements; +using DG.Tweening.Core; +using DG.Tweening.Plugins.Options; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModuleUIToolkit + { + #region Shortcuts + + #region VisualElement + + /// Tweens a VisualElement's position (via style.translate) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMove(this VisualElement target, Vector3 endValue, float duration, bool snapping = false) + { + TweenerCore t + = DOTween.To(() => target.resolvedStyle.translate, x => target.style.translate = new Translate(x.x, x.y, x.z), endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + /// Tweens a VisualElement's position (via style.translate) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMove(this VisualElement target, Vector2 endValue, float duration, bool snapping = false) + { + TweenerCore t + = DOTween.To(() => (Vector2)target.resolvedStyle.translate, x => target.style.translate = x, endValue, duration); + t.SetOptions(snapping).SetTarget(target); + return t; + } + /// Tweens a VisualElement's X position (via style.translate) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveX(this VisualElement target, float endValue, float duration, bool snapping = false) + { + TweenerCore t + = DOTween.To(() => target.resolvedStyle.translate, x => target.style.translate = new Translate(x.x, x.y, x.z), new Vector3(endValue, 0, 0), duration); + t.SetOptions(AxisConstraint.X, snapping).SetTarget(target); + return t; + } + /// Tweens a VisualElement's Y position (via style.translate) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveY(this VisualElement target, float endValue, float duration, bool snapping = false) + { + TweenerCore t + = DOTween.To(() => target.resolvedStyle.translate, x => target.style.translate = new Translate(x.x, x.y, x.z), new Vector3(0, endValue, 0), duration); + t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target); + return t; + } + /// Tweens a VisualElement's Z position (via style.translate) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + /// If TRUE the tween will smoothly snap all values to integers + public static TweenerCore DOMoveZ(this VisualElement target, float endValue, float duration, bool snapping = false) + { + TweenerCore t + = DOTween.To(() => target.resolvedStyle.translate, x => target.style.translate = new Translate(x.x, x.y, x.z), new Vector3(0, 0, endValue), duration); + t.SetOptions(AxisConstraint.Z, snapping).SetTarget(target); + return t; + } + + /// Tweens a VisualElement's scale (via style.scale) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOScale(this VisualElement target, Vector2 endValue, float duration) + { + TweenerCore t + = DOTween.To(() => (Vector2)target.resolvedStyle.scale.value, x => target.style.scale = new Scale(x), endValue, duration); + t.SetTarget(target); + return t; + } + /// Tweens a VisualElement's scale (via style.scale) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DOScale(this VisualElement target, float endValue, float duration) + { + TweenerCore t + = DOTween.To(() => (Vector2)target.resolvedStyle.scale.value, x => target.style.scale = new Scale(x), new Vector2(endValue, endValue), duration); + t.SetTarget(target); + return t; + } + + /// Tweens a VisualElement's rotation (via style.rotate) to the given value. + /// Also stores the VisualElement as the tween's target so it can be used for filtered operations + /// The end value to reachThe duration of the tween + public static TweenerCore DORotate(this VisualElement target, float endValue, float duration) + { + TweenerCore t + = DOTween.To(() => target.resolvedStyle.rotate.angle.value, x => target.style.rotate = new Rotate(x), endValue, duration); + t.SetTarget(target); + return t; + } + + #endregion + + #endregion + } +} +#endif diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs.meta new file mode 100644 index 0000000..8a7c7bf --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUIToolkit.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0c0a6d2683fb84e4193f2aa968264881 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: 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..290189f --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 63c02322328255542995bd02b47b0457 +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs new file mode 100644 index 0000000..5872cc7 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs @@ -0,0 +1,167 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +using System; +using System.Reflection; +using UnityEngine; +using DG.Tweening.Core; +using DG.Tweening.Plugins.Core.PathCore; +using DG.Tweening.Plugins.Options; + +#pragma warning disable 1591 +namespace DG.Tweening +{ + /// + /// Utility functions that deal with available Modules and rewrite them. + /// Modules defines: + /// - DOTAUDIO + /// - DOTPHYSICS + /// - DOTPHYSICS2D + /// - DOTSPRITE + /// - DOTUI + /// Extra defines set and used for implementation of external assets: + /// - DOTWEEN_TMP ► TextMesh Pro + /// - DOTWEEN_TK2D ► 2D Toolkit + /// + public static class DOTweenModuleUtils + { + static bool _initialized; + + #region Reflection + + /// + /// Called via Reflection by DOTweenComponent on Awake + /// +#if UNITY_2018_1_OR_NEWER + [UnityEngine.Scripting.Preserve] +#endif + public static void Init() + { + if (_initialized) return; + + _initialized = true; + DOTweenExternalCommand.SetOrientationOnPath += Physics.SetOrientationOnPath; + +#if UNITY_EDITOR +#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1 + UnityEditor.EditorApplication.playmodeStateChanged += PlaymodeStateChanged; +#else + UnityEditor.EditorApplication.playModeStateChanged += PlaymodeStateChanged; +#endif +#endif + } + +#if UNITY_2018_1_OR_NEWER +#pragma warning disable + [UnityEngine.Scripting.Preserve] + // Just used to preserve methods when building, never called + static void Preserver() + { + Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies(); + MethodInfo mi = typeof(MonoBehaviour).GetMethod("Stub"); + } +#pragma warning restore +#endif + + #endregion + +#if UNITY_EDITOR + // Fires OnApplicationPause in DOTweenComponent even when Editor is paused (otherwise it's only fired at runtime) +#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1 + static void PlaymodeStateChanged() + #else + static void PlaymodeStateChanged(UnityEditor.PlayModeStateChange state) +#endif + { + if (DOTween.instance == null) return; + DOTween.instance.OnApplicationPause(UnityEditor.EditorApplication.isPaused); + } +#endif + + // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ + // ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████ + // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ + + public static class Physics + { + // Called via DOTweenExternalCommand callback + public static void SetOrientationOnPath(PathOptions options, Tween t, Quaternion newRot, Transform trans) + { +#if !DOTWEEN_NOPHYSICS // PHYSICS_MARKER + if (options.isRigidbody) ((Rigidbody)t.target).rotation = newRot; + else trans.rotation = newRot; +#else + trans.rotation = newRot; +#endif + } + + // Returns FALSE if the DOTween's Physics2D Module is disabled, or if there's no Rigidbody2D attached + public static bool HasRigidbody2D(Component target) + { +#if !DOTWEEN_NOPHYSICS2D // PHYSICS2D_MARKER + return target.GetComponent() != null; +#else + return false; +#endif + } + + #region Called via Reflection + + + // Called via Reflection by DOTweenPathInspector + // Returns FALSE if the DOTween's Physics Module is disabled, or if there's no rigidbody attached +#if UNITY_2018_1_OR_NEWER + [UnityEngine.Scripting.Preserve] +#endif + public static bool HasRigidbody(Component target) + { +#if !DOTWEEN_NOPHYSICS // PHYSICS_MARKER + return target.GetComponent() != null; +#else + return false; +#endif + } + + // Called via Reflection by DOTweenPath +#if UNITY_2018_1_OR_NEWER + [UnityEngine.Scripting.Preserve] +#endif + public static TweenerCore CreateDOTweenPathTween( + MonoBehaviour target, bool tweenRigidbody, bool isLocal, Path path, float duration, PathMode pathMode + ){ + TweenerCore t = null; + bool rBodyFoundAndTweened = false; +#if !DOTWEEN_NOPHYSICS // PHYSICS_MARKER + if (tweenRigidbody) { + Rigidbody rBody = target.GetComponent(); + if (rBody != null) { + rBodyFoundAndTweened = true; + t = isLocal + ? rBody.DOLocalPath(path, duration, pathMode) + : rBody.DOPath(path, duration, pathMode); + } + } +#endif +#if !DOTWEEN_NOPHYSICS2D // PHYSICS2D_MARKER + if (!rBodyFoundAndTweened && tweenRigidbody) { + Rigidbody2D rBody2D = target.GetComponent(); + if (rBody2D != null) { + rBodyFoundAndTweened = true; + t = isLocal + ? rBody2D.DOLocalPath(path, duration, pathMode) + : rBody2D.DOPath(path, duration, pathMode); + } + } +#endif + if (!rBodyFoundAndTweened) { + t = isLocal + ? target.transform.DOLocalPath(path, duration, pathMode) + : target.transform.DOPath(path, duration, pathMode); + } + return t; + } + + #endregion + } + } +} diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs.meta b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs.meta new file mode 100644 index 0000000..ab62186 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 7bcaf917d9cf5b84090421a5a2abe42e +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: 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..3799165 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/readme.txt.meta @@ -0,0 +1,4 @@ +fileFormatVersion: 2 +guid: fccfc62abf2eb0a4db614853430894fd +TextScriptImporter: + userData: diff --git a/Assets/Resources.meta b/Assets/Resources.meta new file mode 100644 index 0000000..da2e211 --- /dev/null +++ b/Assets/Resources.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 1e106947f42d0544fb7d228d4b45cad1 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Resources/DOTweenSettings.asset b/Assets/Resources/DOTweenSettings.asset new file mode 100644 index 0000000..8c38d71 --- /dev/null +++ b/Assets/Resources/DOTweenSettings.asset @@ -0,0 +1,55 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &11400000 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 16995157, guid: a811bde74b26b53498b4f6d872b09b6d, type: 3} + m_Name: DOTweenSettings + m_EditorClassIdentifier: + useSafeMode: 1 + safeModeOptions: + logBehaviour: 2 + nestedTweenFailureBehaviour: 0 + timeScale: 1 + unscaledTimeScale: 1 + useSmoothDeltaTime: 0 + maxSmoothUnscaledTime: 0.15 + rewindCallbackMode: 0 + showUnityEditorReport: 0 + logBehaviour: 0 + drawGizmos: 1 + defaultRecyclable: 0 + defaultAutoPlay: 3 + defaultUpdateType: 0 + defaultTimeScaleIndependent: 0 + defaultEaseType: 6 + defaultEaseOvershootOrAmplitude: 1.70158 + defaultEasePeriod: 0 + defaultAutoKill: 1 + defaultLoopType: 0 + debugMode: 0 + debugStoreTargetId: 1 + showPreviewPanel: 1 + storeSettingsLocation: 0 + modules: + showPanel: 0 + audioEnabled: 1 + physicsEnabled: 1 + physics2DEnabled: 1 + spriteEnabled: 1 + uiEnabled: 1 + uiToolkitEnabled: 0 + textMeshProEnabled: 0 + tk2DEnabled: 0 + deAudioEnabled: 0 + deUnityExtendedEnabled: 0 + epoOutlineEnabled: 0 + createASMDEF: 0 + showPlayingTweens: 0 + showPausedTweens: 0 diff --git a/Assets/Resources/DOTweenSettings.asset.meta b/Assets/Resources/DOTweenSettings.asset.meta new file mode 100644 index 0000000..3172c0e --- /dev/null +++ b/Assets/Resources/DOTweenSettings.asset.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 8b8fbbde567890747b4e84ca8d6a3cac +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 11400000 + userData: + assetBundleName: + assetBundleVariant:

2%OvSVC(S!WnlTR%_{-Nt}C+D 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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..61c3cce --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png.meta @@ -0,0 +1,47 @@ +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: 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..c343a61 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenMiniIcon.png.meta @@ -0,0 +1,68 @@ +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: 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..7ca1911 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png.meta @@ -0,0 +1,47 @@ +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: 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..f12a1a7 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png.meta @@ -0,0 +1,47 @@ +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: 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..26e4255 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg.meta @@ -0,0 +1,47 @@ +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: diff --git a/Assets/Plugins/Demigiant/DOTween/Modules.meta b/Assets/Plugins/Demigiant/DOTween/Modules.meta new file mode 100644 index 0000000..24cd2ac --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules.meta @@ -0,0 +1,5 @@ +fileFormatVersion: 2 +guid: 143604b8bad857d47a6f7cc7a533e2dc +folderAsset: yes +DefaultImporter: + userData: diff --git a/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs new file mode 100644 index 0000000..ada1879 --- /dev/null +++ b/Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs @@ -0,0 +1,198 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2018/07/13 + +#if !DOTWEEN_NOAUDIO // MODULE_MARKER +using System; +using DG.Tweening.Core; +using DG.Tweening.Plugins.Options; +using UnityEngine; +using UnityEngine.Audio; // Required for AudioMixer + +#pragma warning disable 1591 +namespace DG.Tweening +{ + public static class DOTweenModuleAudio + { + #region Shortcuts + + #region Audio + + ///