diff options
Diffstat (limited to 'Assets/ThirdParty/Demigiant/DOTweenPro')
23 files changed, 1554 insertions, 0 deletions
diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenAnimation.cs b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenAnimation.cs new file mode 100644 index 00000000..b36860de --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenAnimation.cs @@ -0,0 +1,482 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2015/03/12 15:55 + +using System; +using System.Collections.Generic; +using DG.Tweening.Core; +using UnityEngine; +using UnityEngine.Events; +using UnityEngine.UI; + +#if DOTWEEN_TMP + using TMPro; +#endif + +#pragma warning disable 1591 +namespace DG.Tweening +{ + /// <summary> + /// Attach this to a GameObject to create a tween + /// </summary> + [AddComponentMenu("DOTween/DOTween Animation")] + public class DOTweenAnimation : ABSAnimationComponent + { + public float delay; + public float duration = 1; + public Ease easeType = Ease.OutQuad; + public AnimationCurve easeCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(1, 1)); + public LoopType loopType = LoopType.Restart; + public int loops = 1; + public string id = ""; + public bool isRelative; + public bool isFrom; + public bool isIndependentUpdate = false; + public bool autoKill = true; + + public bool isActive = true; + public bool isValid; + public Component target; + public DOTweenAnimationType animationType; + public bool autoPlay = true; + + public float endValueFloat; + public Vector3 endValueV3; + public Color endValueColor = new Color(1, 1, 1, 1); + public string endValueString = ""; + public Rect endValueRect = new Rect(0, 0, 0, 0); + + public bool optionalBool0; + public float optionalFloat0; + public int optionalInt0; + public RotateMode optionalRotationMode = RotateMode.Fast; + public ScrambleMode optionalScrambleMode = ScrambleMode.None; + public string optionalString; + + int _playCount = -1; // Used when calling DOPlayNext + + #region Unity Methods + + void Awake() + { + if (!isActive || !isValid) return; + + CreateTween(); + } + + void OnDestroy() + { + if (tween != null && tween.IsActive()) tween.Kill(); + tween = null; + } + + // Used also by DOTweenAnimationInspector when applying runtime changes and restarting + public void CreateTween() + { + if (target == null) { + Debug.LogWarning(string.Format("{0} :: This tween's target is NULL, because the animation was created with a DOTween Pro version older than 0.9.255. To fix this, exit Play mode then simply select this object, and it will update automatically", this.gameObject.name), this.gameObject); + return; + } + + Type t = target.GetType(); + +// Component c; + switch (animationType) { + case DOTweenAnimationType.None: + break; + case DOTweenAnimationType.Move: + if (t.IsSameOrSubclassOf(typeof(RectTransform))) tween = ((RectTransform)target).DOAnchorPos3D(endValueV3, duration, optionalBool0); + else if (t.IsSameOrSubclassOf(typeof(Transform))) tween = ((Transform)target).DOMove(endValueV3, duration, optionalBool0); + else if (t.IsSameOrSubclassOf(typeof(Rigidbody2D))) tween = ((Rigidbody2D)target).DOMove(endValueV3, duration, optionalBool0); + else if (t.IsSameOrSubclassOf(typeof(Rigidbody))) tween = ((Rigidbody)target).DOMove(endValueV3, duration, optionalBool0); +// c = this.GetComponent<Rigidbody2D>(); +// if (c != null) { +// tween = ((Rigidbody2D)c).DOMove(endValueV3, duration, optionalBool0); +// goto SetupTween; +// } +// c = this.GetComponent<Rigidbody>(); +// if (c != null) { +// tween = ((Rigidbody)c).DOMove(endValueV3, duration, optionalBool0); +// goto SetupTween; +// } +// c = this.GetComponent<RectTransform>(); +// if (c != null) { +// tween = ((RectTransform)c).DOAnchorPos3D(endValueV3, duration, optionalBool0); +// goto SetupTween; +// } +// tween = transform.DOMove(endValueV3, duration, optionalBool0); + break; + case DOTweenAnimationType.LocalMove: + tween = transform.DOLocalMove(endValueV3, duration, optionalBool0); + break; + case DOTweenAnimationType.Rotate: + if (t.IsSameOrSubclassOf(typeof(Transform))) tween = ((Transform)target).DORotate(endValueV3, duration, optionalRotationMode); + else if (t.IsSameOrSubclassOf(typeof(Rigidbody2D))) tween = ((Rigidbody2D)target).DORotate(endValueFloat, duration); + else if (t.IsSameOrSubclassOf(typeof(Rigidbody))) tween = ((Rigidbody)target).DORotate(endValueV3, duration, optionalRotationMode); +// c = this.GetComponent<Rigidbody2D>(); +// if (c != null) { +// tween = ((Rigidbody2D)c).DORotate(endValueFloat, duration); +// goto SetupTween; +// } +// c = this.GetComponent<Rigidbody>(); +// if (c != null) { +// tween = ((Rigidbody)c).DORotate(endValueV3, duration, optionalRotationMode); +// goto SetupTween; +// } +// tween = transform.DORotate(endValueV3, duration, optionalRotationMode); + break; + case DOTweenAnimationType.LocalRotate: + tween = transform.DOLocalRotate(endValueV3, duration, optionalRotationMode); + break; + case DOTweenAnimationType.Scale: + tween = transform.DOScale(optionalBool0 ? new Vector3(endValueFloat, endValueFloat, endValueFloat) : endValueV3, duration); + break; + case DOTweenAnimationType.Color: + isRelative = false; + if (t.IsSameOrSubclassOf(typeof(SpriteRenderer))) tween = ((SpriteRenderer)target).DOColor(endValueColor, duration); + else if (t.IsSameOrSubclassOf(typeof(Renderer))) tween = ((Renderer)target).material.DOColor(endValueColor, duration); + else if (t.IsSameOrSubclassOf(typeof(Image))) tween = ((Image)target).DOColor(endValueColor, duration); + else if (t.IsSameOrSubclassOf(typeof(Text))) tween = ((Text)target).DOColor(endValueColor, duration); +#if DOTWEEN_TK2D + else if (t.IsSameOrSubclassOf(typeof(tk2dTextMesh))) tween = ((tk2dTextMesh)target).DOColor(endValueColor, duration); + else if (t.IsSameOrSubclassOf(typeof(tk2dBaseSprite))) tween = ((tk2dBaseSprite)target).DOColor(endValueColor, duration); +// c = this.GetComponent<tk2dBaseSprite>(); +// if (c != null) { +// tween = ((tk2dBaseSprite)c).DOColor(endValueColor, duration); +// goto SetupTween; +// } +#endif +#if DOTWEEN_TMP + else if (t.IsSameOrSubclassOf(typeof(TextMeshProUGUI))) tween = ((TextMeshProUGUI)target).DOColor(endValueColor, duration); + else if (t.IsSameOrSubclassOf(typeof(TextMeshPro))) tween = ((TextMeshPro)target).DOColor(endValueColor, duration); +// c = this.GetComponent<TextMeshPro>(); +// if (c != null) { +// tween = ((TextMeshPro)c).DOColor(endValueColor, duration); +// goto SetupTween; +// } +// c = this.GetComponent<TextMeshProUGUI>(); +// if (c != null) { +// tween = ((TextMeshProUGUI)c).DOColor(endValueColor, duration); +// goto SetupTween; +// } +#endif +// c = this.GetComponent<SpriteRenderer>(); +// if (c != null) { +// tween = ((SpriteRenderer)c).DOColor(endValueColor, duration); +// goto SetupTween; +// } +// c = this.GetComponent<Renderer>(); +// if (c != null) { +// tween = ((Renderer)c).material.DOColor(endValueColor, duration); +// goto SetupTween; +// } +// c = this.GetComponent<Image>(); +// if (c != null) { +// tween = ((Image)c).DOColor(endValueColor, duration); +// goto SetupTween; +// } +// c = this.GetComponent<Text>(); +// if (c != null) { +// tween = ((Text)c).DOColor(endValueColor, duration); +// goto SetupTween; +// } + break; + case DOTweenAnimationType.Fade: + isRelative = false; + if (t.IsSameOrSubclassOf(typeof(SpriteRenderer))) tween = ((SpriteRenderer)target).DOFade(endValueFloat, duration); + else if (t.IsSameOrSubclassOf(typeof(Renderer))) tween = ((Renderer)target).material.DOFade(endValueFloat, duration); + else if (t.IsSameOrSubclassOf(typeof(Image))) tween = ((Image)target).DOFade(endValueFloat, duration); + else if (t.IsSameOrSubclassOf(typeof(Text))) tween = ((Text)target).DOFade(endValueFloat, duration); +#if DOTWEEN_TK2D + else if (t.IsSameOrSubclassOf(typeof(tk2dTextMesh))) tween = ((tk2dTextMesh)target).DOFade(endValueFloat, duration); + else if (t.IsSameOrSubclassOf(typeof(tk2dBaseSprite))) tween = ((tk2dBaseSprite)target).DOFade(endValueFloat, duration); +// c = this.GetComponent<tk2dBaseSprite>(); +// if (c != null) { +// tween = ((tk2dBaseSprite)c).DOFade(endValueFloat, duration); +// goto SetupTween; +// } +#endif +#if DOTWEEN_TMP + else if (t.IsSameOrSubclassOf(typeof(TextMeshProUGUI))) tween = ((TextMeshProUGUI)target).DOFade(endValueFloat, duration); + else if (t.IsSameOrSubclassOf(typeof(TextMeshPro))) tween = ((TextMeshPro)target).DOFade(endValueFloat, duration); +// c = this.GetComponent<TextMeshPro>(); +// if (c != null) { +// tween = ((TextMeshPro)c).DOFade(endValueFloat, duration); +// goto SetupTween; +// } +// c = this.GetComponent<TextMeshProUGUI>(); +// if (c != null) { +// tween = ((TextMeshProUGUI)c).DOFade(endValueFloat, duration); +// goto SetupTween; +// } +#endif +// c = this.GetComponent<SpriteRenderer>(); +// if (c != null) { +// tween = ((SpriteRenderer)c).DOFade(endValueFloat, duration); +// goto SetupTween; +// } +// c = this.GetComponent<Renderer>(); +// if (c != null) { +// tween = ((Renderer)c).material.DOFade(endValueFloat, duration); +// goto SetupTween; +// } +// c = this.GetComponent<Image>(); +// if (c != null) { +// tween = ((Image)c).DOFade(endValueFloat, duration); +// goto SetupTween; +// } +// c = this.GetComponent<Text>(); +// if (c != null) { +// tween = ((Text)c).DOFade(endValueFloat, duration); +// goto SetupTween; +// } + break; + case DOTweenAnimationType.Text: + if (t.IsSameOrSubclassOf(typeof(Text))) tween = ((Text)target).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString); +// c = this.GetComponent<Text>(); +// if (c != null) { +// tween = ((Text)c).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString); +// goto SetupTween; +// } +#if DOTWEEN_TK2D + else if (t.IsSameOrSubclassOf(typeof(tk2dTextMesh))) tween = ((tk2dTextMesh)target).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString); +// c = this.GetComponent<tk2dTextMesh>(); +// if (c != null) { +// tween = ((tk2dTextMesh)c).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString); +// goto SetupTween; +// } +#endif +#if DOTWEEN_TMP + else if (t.IsSameOrSubclassOf(typeof(TextMeshProUGUI))) tween = ((TextMeshProUGUI)target).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString); + else if (t.IsSameOrSubclassOf(typeof(TextMeshPro))) tween = ((TextMeshPro)target).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString); +// c = this.GetComponent<TextMeshPro>(); +// if (c != null) { +// tween = ((TextMeshPro)c).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString); +// goto SetupTween; +// } +// c = this.GetComponent<TextMeshProUGUI>(); +// if (c != null) { +// tween = ((TextMeshProUGUI)c).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString); +// goto SetupTween; +// } +#endif + break; + case DOTweenAnimationType.PunchPosition: + if (t.IsSameOrSubclassOf(typeof(RectTransform))) tween = ((RectTransform)target).DOPunchAnchorPos(endValueV3, duration, optionalInt0, optionalFloat0, optionalBool0); + else if (t.IsSameOrSubclassOf(typeof(Transform))) tween = ((Transform)target).DOPunchPosition(endValueV3, duration, optionalInt0, optionalFloat0, optionalBool0); +// tween = transform.DOPunchPosition(endValueV3, duration, optionalInt0, optionalFloat0, optionalBool0); + break; + case DOTweenAnimationType.PunchScale: + tween = transform.DOPunchScale(endValueV3, duration, optionalInt0, optionalFloat0); + break; + case DOTweenAnimationType.PunchRotation: + tween = transform.DOPunchRotation(endValueV3, duration, optionalInt0, optionalFloat0); + break; + case DOTweenAnimationType.ShakePosition: + if (t.IsSameOrSubclassOf(typeof(RectTransform))) tween = ((RectTransform)target).DOShakeAnchorPos(duration, endValueV3, optionalInt0, optionalFloat0, optionalBool0); + if (t.IsSameOrSubclassOf(typeof(Transform))) tween = ((Transform)target).DOShakePosition(duration, endValueV3, optionalInt0, optionalFloat0, optionalBool0); +// tween = transform.DOShakePosition(duration, endValueV3, optionalInt0, optionalFloat0, optionalBool0); + break; + case DOTweenAnimationType.ShakeScale: + tween = transform.DOShakeScale(duration, endValueV3, optionalInt0, optionalFloat0); + break; + case DOTweenAnimationType.ShakeRotation: + tween = transform.DOShakeRotation(duration, endValueV3, optionalInt0, optionalFloat0); + break; + case DOTweenAnimationType.CameraAspect: + tween = ((Camera)target).DOAspect(endValueFloat, duration); + break; + case DOTweenAnimationType.CameraBackgroundColor: + tween = ((Camera)target).DOColor(endValueColor, duration); + break; + case DOTweenAnimationType.CameraFieldOfView: + tween = ((Camera)target).DOFieldOfView(endValueFloat, duration); + break; + case DOTweenAnimationType.CameraOrthoSize: + tween = ((Camera)target).DOOrthoSize(endValueFloat, duration); + break; + case DOTweenAnimationType.CameraPixelRect: + tween = ((Camera)target).DOPixelRect(endValueRect, duration); + break; + case DOTweenAnimationType.CameraRect: + tween = ((Camera)target).DORect(endValueRect, duration); + break; + } + +// SetupTween: + if (tween == null) return; + + if (isFrom) { + ((Tweener)tween).From(isRelative); + } else { + tween.SetRelative(isRelative); + } + tween.SetTarget(this.gameObject).SetDelay(delay).SetLoops(loops, loopType).SetAutoKill(autoKill) + .OnKill(()=> tween = null); + if (easeType == Ease.INTERNAL_Custom) tween.SetEase(easeCurve); + else tween.SetEase(easeType); + if (!string.IsNullOrEmpty(id)) tween.SetId(id); + tween.SetUpdate(isIndependentUpdate); + + if (hasOnStart) { + if (onStart != null) tween.OnStart(onStart.Invoke); + } else onStart = null; + if (hasOnPlay) { + if (onPlay != null) tween.OnPlay(onPlay.Invoke); + } else onPlay = null; + if (hasOnUpdate) { + if (onUpdate != null) tween.OnUpdate(onUpdate.Invoke); + } else onUpdate = null; + if (hasOnStepComplete) { + if (onStepComplete != null) tween.OnStepComplete(onStepComplete.Invoke); + } else onStepComplete = null; + if (hasOnComplete) { + if (onComplete != null) tween.OnComplete(onComplete.Invoke); + } else onComplete = null; + + if (autoPlay) tween.Play(); + else tween.Pause(); + } + + #endregion + + #region Public Methods + + // These methods are here so they can be called directly via Unity's UGUI event system + + public override void DOPlay() + { + DOTween.Play(this.gameObject); + } + + public override void DOPlayBackwards() + { + DOTween.PlayBackwards(this.gameObject); + } + + public override void DOPlayForward() + { + DOTween.PlayForward(this.gameObject); + } + + public override void DOPause() + { + DOTween.Pause(this.gameObject); + } + + public override void DOTogglePause() + { + DOTween.TogglePause(this.gameObject); + } + + public override void DORewind() + { + _playCount = -1; + // Rewind using Components order (in case there are multiple animations on the same property) + DOTweenAnimation[] anims = this.gameObject.GetComponents<DOTweenAnimation>(); + for (int i = anims.Length - 1; i > -1; --i) { + Tween t = anims[i].tween; + if (t != null && t.IsInitialized()) anims[i].tween.Rewind(); + } + // DOTween.Rewind(this.gameObject); + } + + /// <summary> + /// Restarts the tween + /// </summary> + /// <param name="fromHere">If TRUE, re-evaluates the tween's start and end values from its current position. + /// Set it to TRUE when spawning the same DOTweenAnimation in different positions (like when using a pooling system)</param> + public override void DORestart(bool fromHere = false) + { + _playCount = -1; + if (tween == null) { + if (Debugger.logPriority > 1) Debugger.LogNullTween(tween); return; + } + if (fromHere && isRelative) ReEvaluateRelativeTween(); + DOTween.Restart(this.gameObject); + } + + public override void DOComplete() + { + DOTween.Complete(this.gameObject); + } + + public override void DOKill() + { + DOTween.Kill(this.gameObject); + tween = null; + } + + #region Specifics + + public void DOPlayById(string id) + { + DOTween.Play(this.gameObject, id); + } + public void DOPlayAllById(string id) + { + DOTween.Play(id); + } + + public void DOPlayNext() + { + DOTweenAnimation[] anims = this.GetComponents<DOTweenAnimation>(); + while (_playCount < anims.Length - 1) { + _playCount++; + DOTweenAnimation anim = anims[_playCount]; + if (anim != null && anim.tween != null && !anim.tween.IsPlaying() && !anim.tween.IsComplete()) { + anim.tween.Play(); + break; + } + } + } + + public void DORewindAndPlayNext() + { + _playCount = -1; + DOTween.Rewind(this.gameObject); + DOPlayNext(); + } + + public void DORestartById(string id) + { + _playCount = -1; + DOTween.Restart(this.gameObject, id); + } + public void DORestartAllById(string id) + { + _playCount = -1; + DOTween.Restart(id); + } + + public List<Tween> GetTweens() + { + return DOTween.TweensByTarget(this.gameObject); + } + + #endregion + + #endregion + + #region Private + + // Re-evaluate relative position of path + void ReEvaluateRelativeTween() + { + if (animationType == DOTweenAnimationType.Move) { + ((Tweener)tween).ChangeEndValue(transform.position + endValueV3, true); + } else if (animationType == DOTweenAnimationType.LocalMove) { + ((Tweener)tween).ChangeEndValue(transform.localPosition + endValueV3, true); + } + } + + #endregion + } + + public static class DOTweenAnimationExtensions + { + public static bool IsSameOrSubclassOf(this Type t, Type tBase) + { + return t.IsSubclassOf(tBase) || t == tBase; + } + } +}
\ No newline at end of file diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenAnimation.cs.meta b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenAnimation.cs.meta new file mode 100644 index 00000000..a10ceea2 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenAnimation.cs.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 4d0390bd8b8ffd640b34fe25065ff1df +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.XML b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.XML new file mode 100644 index 00000000..6f5f6c86 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.XML @@ -0,0 +1,71 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>DOTweenPro</name> + </assembly> + <members> + <member name="T:DG.Tweening.ShortcutExtensionsPro"> + <summary> + Methods that extend known Unity objects and allow to directly create and control tweens from their instances + </summary> + </member> + <member name="M:DG.Tweening.ShortcutExtensionsPro.DOSpiral(UnityEngine.Transform,System.Single,System.Nullable{UnityEngine.Vector3},DG.Tweening.SpiralMode,System.Single,System.Single,System.Single,System.Boolean)"> + <summary>Tweens a Transform's localPosition in a spiral shape. + Also stores the transform as the tween's target so it can be used for filtered operations</summary> + <param name="duration">The duration of the tween</param> + <param name="axis">The axis around which the spiral will rotate</param> + <param name="mode">The type of spiral movement</param> + <param name="speed">Speed of the rotations</param> + <param name="frequency">Frequency of the rotation. Lower values lead to wider spirals</param> + <param name="depth">Indicates how much the tween should move along the spiral's axis</param> + <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param> + </member> + <member name="M:DG.Tweening.ShortcutExtensionsPro.DOSpiral(UnityEngine.Rigidbody,System.Single,System.Nullable{UnityEngine.Vector3},DG.Tweening.SpiralMode,System.Single,System.Single,System.Single,System.Boolean)"> + <summary>Tweens a Rigidbody's position in a spiral shape. + Also stores the transform as the tween's target so it can be used for filtered operations</summary> + <param name="duration">The duration of the tween</param> + <param name="axis">The axis around which the spiral will rotate</param> + <param name="mode">The type of spiral movement</param> + <param name="speed">Speed of the rotations</param> + <param name="frequency">Frequency of the rotation. Lower values lead to wider spirals</param> + <param name="depth">Indicates how much the tween should move along the spiral's axis</param> + <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param> + </member> + <member name="T:DG.Tweening.Plugins.SpiralPlugin"> + <summary> + Tweens a Vector3 along a spiral. + EndValue represents the direction of the spiral + </summary> + </member> + <member name="M:DG.Tweening.Core.ABSAnimationComponent.DORestart(System.Boolean)"> + <summary> + Restarts the tween + </summary> + <param name="fromHere">If TRUE, re-evaluates the tween's start and end values from its current position. + Set it to TRUE when spawning the same DOTweenPath in different positions (like when using a pooling system)</param> + </member> + <member name="T:DG.Tweening.DOTweenPath"> + <summary> + Attach this to a GameObject to create and assign a path to it + </summary> + </member> + <member name="M:DG.Tweening.DOTweenPath.DORestart(System.Boolean)"> + <summary> + Restarts the tween + </summary> + <param name="fromHere">If TRUE, re-evaluates the tween's start and end values from its current position. + Set it to TRUE when spawning the same DOTweenPath in different positions (like when using a pooling system)</param> + </member> + <member name="T:DG.Tweening.SpiralMode"> + <summary> + Spiral tween mode + </summary> + </member> + <member name="F:DG.Tweening.SpiralMode.Expand"> + <summary>The spiral motion will expand outwards for the whole the tween</summary> + </member> + <member name="F:DG.Tweening.SpiralMode.ExpandThenContract"> + <summary>The spiral motion will expand outwards for half the tween and then will spiral back to the starting position</summary> + </member> + </members> +</doc> diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.XML.meta b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.XML.meta new file mode 100644 index 00000000..ddc78e5f --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.XML.meta @@ -0,0 +1,4 @@ +fileFormatVersion: 2 +guid: db7d7ef84c388bc4fbc3835d31a15306 +TextScriptImporter: + userData: diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.dll b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.dll Binary files differnew file mode 100644 index 00000000..f3a36555 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.dll diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.dll.mdb b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.dll.mdb Binary files differnew file mode 100644 index 00000000..6c4206a4 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.dll.mdb diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.dll.mdb.meta b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.dll.mdb.meta new file mode 100644 index 00000000..69790909 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.dll.mdb.meta @@ -0,0 +1,4 @@ +fileFormatVersion: 2 +guid: d719ed2e2c87eae4e8dd520e2df659c1 +DefaultImporter: + userData: diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.dll.meta b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.dll.meta new file mode 100644 index 00000000..4b9d81f7 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenPro.dll.meta @@ -0,0 +1,33 @@ +fileFormatVersion: 2 +guid: aa0b1eebb5db27a419fa4564bbe5c9c5 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenTextMeshPro.cs.addon b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenTextMeshPro.cs.addon new file mode 100644 index 00000000..94239cad --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenTextMeshPro.cs.addon @@ -0,0 +1,239 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2015/03/27 19:02 +// +// License Copyright (c) Daniele Giardini. +// This work is subject to the terms at http://dotween.demigiant.com/license.php + +using UnityEngine; +using TMPro; + +namespace DG.Tweening +{ + /// <summary> + /// Methods that extend Text Mesh Pro objects and allow to directly create and control tweens from their instances. + /// </summary> + public static class ShortcutExtensionsTextMeshPro + { + #region Colors + + /// <summary>Tweens a TextMeshPro's color to the given value. + /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOColor(this TextMeshPro target, Color endValue, float duration) + { + return DOTween.To(() => target.color, x => target.color = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a TextMeshPro's faceColor to the given value. + /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOFaceColor(this TextMeshPro target, Color32 endValue, float duration) + { + return DOTween.To(() => target.faceColor, x => target.faceColor = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a TextMeshPro's outlineColor to the given value. + /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOOutlineColor(this TextMeshPro target, Color32 endValue, float duration) + { + return DOTween.To(() => target.outlineColor, x => target.outlineColor = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a TextMeshPro's glow color to the given value. + /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + /// <param name="useSharedMaterial">If TRUE will use the fontSharedMaterial instead than the fontMaterial</param> + public static Tweener DOGlowColor(this TextMeshPro target, Color endValue, float duration, bool useSharedMaterial = false) + { + return useSharedMaterial + ? target.fontSharedMaterial.DOColor(endValue, "_GlowColor", duration).SetTarget(target) + : target.fontMaterial.DOColor(endValue, "_GlowColor", duration).SetTarget(target); + } + + /// <summary>Tweens a TextMeshPro's alpha color to the given value. + /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOFade(this TextMeshPro target, float endValue, float duration) + { + return DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a TextMeshPro faceColor's alpha to the given value. + /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOFaceFade(this TextMeshPro target, float endValue, float duration) + { + return DOTween.ToAlpha(() => target.faceColor, x => target.faceColor = x, endValue, duration) + .SetTarget(target); + } + + #endregion + + #region Other + + /// <summary>Tweens a TextMeshPro's scale to the given value (using correct uniform scale as TMP requires). + /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOScale(this TextMeshPro target, float endValue, float duration) + { + Transform t = target.transform; + Vector3 endValueV3 = new Vector3(endValue, endValue, endValue); + return DOTween.To(() => t.localScale, x => t.localScale = x, endValueV3, duration).SetTarget(target); + } + + /// <summary>Tweens a TextMeshPro's fontSize to the given value. + /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOFontSize(this TextMeshPro target, float endValue, float duration) + { + return DOTween.To(() => target.fontSize, x => target.fontSize = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a TextMeshPro's maxVisibleCharacters to the given value. + /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOMaxVisibleCharacters(this TextMeshPro target, int endValue, float duration) + { + return DOTween.To(() => target.maxVisibleCharacters, x => target.maxVisibleCharacters = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a TextMeshPro's text to the given value. + /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param> + /// <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated, + /// otherwise all tags will be considered as normal text</param> + /// <param name="scrambleMode">The type of scramble mode to use, if any</param> + /// <param name="scrambleChars">A string containing the characters to use for scrambling. + /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters. + /// Leave it to NULL (default) to use default ones</param> + public static Tweener DOText(this TextMeshPro target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null) + { + return DOTween.To(() => target.text, x => target.text = x, endValue, duration) + .SetOptions(richTextEnabled, scrambleMode, scrambleChars) + .SetTarget(target); + } + + #endregion + } + + /// <summary> + /// Methods that extend Text Mesh Pro objects and allow to directly create and control tweens from their instances. + /// </summary> + public static class ShortcutExtensionsTextMeshProUGUI + { + #region Colors + + /// <summary>Tweens a TextMeshProUGUI's color to the given value. + /// Also stores the TextMeshProUGUI as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOColor(this TextMeshProUGUI target, Color endValue, float duration) + { + return DOTween.To(() => target.color, x => target.color = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a TextMeshProUGUI's faceColor to the given value. + /// Also stores the TextMeshProUGUI as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOFaceColor(this TextMeshProUGUI target, Color32 endValue, float duration) + { + return DOTween.To(() => target.faceColor, x => target.faceColor = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a TextMeshProUGUI's outlineColor to the given value. + /// Also stores the TextMeshProUGUI as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOOutlineColor(this TextMeshProUGUI target, Color32 endValue, float duration) + { + return DOTween.To(() => target.outlineColor, x => target.outlineColor = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a TextMeshProUGUI's glow color to the given value. + /// Also stores the TextMeshProUGUI as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + /// <param name="useSharedMaterial">If TRUE will use the fontSharedMaterial instead than the fontMaterial</param> + public static Tweener DOGlowColor(this TextMeshProUGUI target, Color endValue, float duration, bool useSharedMaterial = false) + { + return useSharedMaterial + ? target.fontSharedMaterial.DOColor(endValue, "_GlowColor", duration).SetTarget(target) + : target.fontMaterial.DOColor(endValue, "_GlowColor", duration).SetTarget(target); + } + + /// <summary>Tweens a TextMeshProUGUI's alpha color to the given value. + /// Also stores the TextMeshProUGUI as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOFade(this TextMeshProUGUI target, float endValue, float duration) + { + return DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a TextMeshProUGUI faceColor's alpha to the given value. + /// Also stores the TextMeshProUGUI as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOFaceFade(this TextMeshProUGUI target, float endValue, float duration) + { + return DOTween.ToAlpha(() => target.faceColor, x => target.faceColor = x, endValue, duration) + .SetTarget(target); + } + + #endregion + + #region Other + + /// <summary>Tweens a TextMeshProUGUI's scale to the given value (using correct uniform scale as TMP requires). + /// Also stores the TextMeshProUGUI as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOScale(this TextMeshProUGUI target, float endValue, float duration) + { + Transform t = target.transform; + Vector3 endValueV3 = new Vector3(endValue, endValue, endValue); + return DOTween.To(() => t.localScale, x => t.localScale = x, endValueV3, duration).SetTarget(target); + } + + /// <summary>Tweens a TextMeshProUGUI's fontSize to the given value. + /// Also stores the TextMeshProUGUI as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOFontSize(this TextMeshProUGUI target, float endValue, float duration) + { + return DOTween.To(() => target.fontSize, x => target.fontSize = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a TextMeshProUGUI's maxVisibleCharacters to the given value. + /// Also stores the TextMeshProUGUI as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOMaxVisibleCharacters(this TextMeshProUGUI target, int endValue, float duration) + { + return DOTween.To(() => target.maxVisibleCharacters, x => target.maxVisibleCharacters = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a TextMeshProUGUI's text to the given value. + /// Also stores the TextMeshProUGUI as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param> + /// <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated, + /// otherwise all tags will be considered as normal text</param> + /// <param name="scrambleMode">The type of scramble mode to use, if any</param> + /// <param name="scrambleChars">A string containing the characters to use for scrambling. + /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters. + /// Leave it to NULL (default) to use default ones</param> + public static Tweener DOText(this TextMeshProUGUI target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null) + { + return DOTween.To(() => target.text, x => target.text = x, endValue, duration) + .SetOptions(richTextEnabled, scrambleMode, scrambleChars) + .SetTarget(target); + } + + #endregion + } +}
\ No newline at end of file diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenTextMeshPro.cs.addon.meta b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenTextMeshPro.cs.addon.meta new file mode 100644 index 00000000..d5f3e922 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenTextMeshPro.cs.addon.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 8eb04b85cc6f89344a7c271e1bfef46d +timeCreated: 1428774842 +licenseType: Store +DefaultImporter: + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenTk2d.cs.addon b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenTk2d.cs.addon new file mode 100644 index 00000000..f5e5ef17 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenTk2d.cs.addon @@ -0,0 +1,143 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2014/10/27 15:59 +// +// License Copyright (c) Daniele Giardini. +// This work is subject to the terms at http://dotween.demigiant.com/license.php + +using UnityEngine; + +namespace DG.Tweening +{ + /// <summary> + /// Methods that extend 2D Toolkit objects and allow to directly create and control tweens from their instances. + /// </summary> + public static class ShortcutExtensionsTk2d + { + #region Sprite + + /// <summary>Tweens a 2D Toolkit Sprite's dimensions to the given value. + /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOScale(this tk2dBaseSprite target, Vector3 endValue, float duration) + { + return DOTween.To(() => target.scale, x => target.scale = x, endValue, duration) + .SetTarget(target); + } + /// <summary>Tweens a Sprite's dimensions to the given value. + /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOScaleX(this tk2dBaseSprite target, float endValue, float duration) + { + return DOTween.To(() => target.scale, x => target.scale = x, new Vector3(endValue, 0, 0), duration) + .SetOptions(AxisConstraint.X) + .SetTarget(target); + } + /// <summary>Tweens a Sprite's dimensions to the given value. + /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOScaleY(this tk2dBaseSprite target, float endValue, float duration) + { + return DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, endValue, 0), duration) + .SetOptions(AxisConstraint.Y) + .SetTarget(target); + } + /// <summary>Tweens a Sprite's dimensions to the given value. + /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOScaleZ(this tk2dBaseSprite target, float endValue, float duration) + { + return DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, 0, endValue), duration) + .SetOptions(AxisConstraint.Z) + .SetTarget(target); + } + + /// <summary>Tweens a 2D Toolkit Sprite's color to the given value. + /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOColor(this tk2dBaseSprite target, Color endValue, float duration) + { + return DOTween.To(() => target.color, x => target.color = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a 2D Toolkit Sprite's alpha color to the given value. + /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOFade(this tk2dBaseSprite target, float endValue, float duration) + { + return DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration) + .SetTarget(target); + } + + #endregion + + #region tk2dSlicedSprite + + /// <summary>Tweens a 2D Toolkit SlicedSprite's dimensions to the given value. + /// Also stores the SlicedSprite as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOScale(this tk2dSlicedSprite target, Vector2 endValue, float duration) + { + return DOTween.To(() => target.dimensions, x => target.dimensions = x, endValue, duration) + .SetTarget(target); + } + /// <summary>Tweens a SlicedSprite's dimensions to the given value. + /// Also stores the SlicedSprite as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOScaleX(this tk2dSlicedSprite target, float endValue, float duration) + { + return DOTween.To(() => target.dimensions, x => target.dimensions = x, new Vector2(endValue, 0), duration) + .SetOptions(AxisConstraint.X) + .SetTarget(target); + } + /// <summary>Tweens a SlicedSprite's dimensions to the given value. + /// Also stores the SlicedSprite as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOScaleY(this tk2dSlicedSprite target, float endValue, float duration) + { + return DOTween.To(() => target.dimensions, x => target.dimensions = x, new Vector2(0, endValue), duration) + .SetOptions(AxisConstraint.Y) + .SetTarget(target); + } + + #endregion + + #region TextMesh + + /// <summary>Tweens a 2D Toolkit TextMesh's color to the given value. + /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOColor(this tk2dTextMesh target, Color endValue, float duration) + { + return DOTween.To(() => target.color, x => target.color = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a 2D Toolkit TextMesh's alpha color to the given value. + /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param> + public static Tweener DOFade(this tk2dTextMesh target, float endValue, float duration) + { + return DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration) + .SetTarget(target); + } + + /// <summary>Tweens a tk2dTextMesh's text to the given value. + /// Also stores the tk2dTextMesh as the tween's target so it can be used for filtered operations</summary> + /// <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param> + /// <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated, + /// otherwise all tags will be considered as normal text</param> + /// <param name="scrambleMode">The type of scramble mode to use, if any</param> + /// <param name="scrambleChars">A string containing the characters to use for scrambling. + /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters. + /// Leave it to NULL (default) to use default ones</param> + public static Tweener DOText(this tk2dTextMesh target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null) + { + return DOTween.To(() => target.text, x => target.text = x, endValue, duration) + .SetOptions(richTextEnabled, scrambleMode, scrambleChars) + .SetTarget(target); + } + + #endregion + } +}
\ No newline at end of file diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenTk2d.cs.addon.meta b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenTk2d.cs.addon.meta new file mode 100644 index 00000000..e42b2bb9 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/DOTweenTk2d.cs.addon.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 696fb534c77ea9241a70586ef5260a92 +timeCreated: 1428774842 +licenseType: Store +DefaultImporter: + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/Editor.meta b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor.meta new file mode 100644 index 00000000..e9164f71 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor.meta @@ -0,0 +1,5 @@ +fileFormatVersion: 2 +guid: 34ca5bde92f87fa4dbeb9593d201fde2 +folderAsset: yes +DefaultImporter: + userData: diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenAnimationInspector.cs b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenAnimationInspector.cs new file mode 100644 index 00000000..168b025e --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenAnimationInspector.cs @@ -0,0 +1,453 @@ +// Author: Daniele Giardini - http://www.demigiant.com +// Created: 2015/03/12 16:03 + +using System; +using System.Collections.Generic; +using System.IO; +using DG.DemiEditor; +using DG.DOTweenEditor.Core; +using DG.Tweening; +using DG.Tweening.Core; +using UnityEditor; +using UnityEngine; +using UnityEngine.UI; + +#if DOTWEEN_TMP + using TMPro; +#endif + +namespace DG.DOTweenEditor +{ + [CustomEditor(typeof(DOTweenAnimation))] + public class DOTweenAnimationInspector : ABSAnimationInspector + { + static readonly Dictionary<DOTweenAnimationType, Type[]> _AnimationTypeToComponent = new Dictionary<DOTweenAnimationType, Type[]>() { + { DOTweenAnimationType.Move, new[] { typeof(Rigidbody), typeof(Rigidbody2D), typeof(RectTransform), typeof(Transform) } }, + { DOTweenAnimationType.LocalMove, new[] { typeof(Transform) } }, + { DOTweenAnimationType.Rotate, new[] { typeof(Rigidbody), typeof(Rigidbody2D), typeof(Transform) } }, + { DOTweenAnimationType.LocalRotate, new[] { typeof(Transform) } }, + { DOTweenAnimationType.Scale, new[] { typeof(Transform) } }, + { DOTweenAnimationType.Color, new[] { typeof(SpriteRenderer), typeof(Renderer), typeof(Image), typeof(Text) } }, + { DOTweenAnimationType.Fade, new[] { typeof(SpriteRenderer), typeof(Renderer), typeof(Image), typeof(Text) } }, + { DOTweenAnimationType.Text, new[] { typeof(Text) } }, + { DOTweenAnimationType.PunchPosition, new[] { typeof(RectTransform), typeof(Transform) } }, + { DOTweenAnimationType.PunchRotation, new[] { typeof(Transform) } }, + { DOTweenAnimationType.PunchScale, new[] { typeof(Transform) } }, + { DOTweenAnimationType.ShakePosition, new[] { typeof(RectTransform), typeof(Transform) } }, + { DOTweenAnimationType.ShakeRotation, new[] { typeof(Transform) } }, + { DOTweenAnimationType.ShakeScale, new[] { typeof(Transform) } }, + { DOTweenAnimationType.CameraAspect, new[] { typeof(Camera) } }, + { DOTweenAnimationType.CameraBackgroundColor, new[] { typeof(Camera) } }, + { DOTweenAnimationType.CameraFieldOfView, new[] { typeof(Camera) } }, + { DOTweenAnimationType.CameraOrthoSize, new[] { typeof(Camera) } }, + { DOTweenAnimationType.CameraPixelRect, new[] { typeof(Camera) } }, + { DOTweenAnimationType.CameraRect, new[] { typeof(Camera) } }, + }; + +#if DOTWEEN_TK2D + static readonly Dictionary<DOTweenAnimationType, Type[]> _Tk2dAnimationTypeToComponent = new Dictionary<DOTweenAnimationType, Type[]>() { + { DOTweenAnimationType.Color, new[] { typeof(tk2dBaseSprite), typeof(tk2dTextMesh) } }, + { DOTweenAnimationType.Fade, new[] { typeof(tk2dBaseSprite), typeof(tk2dTextMesh) } }, + { DOTweenAnimationType.Text, new[] { typeof(tk2dTextMesh) } } + }; +#endif +#if DOTWEEN_TMP + static readonly Dictionary<DOTweenAnimationType, Type[]> _TMPAnimationTypeToComponent = new Dictionary<DOTweenAnimationType, Type[]>() { + { DOTweenAnimationType.Color, new[] { typeof(TextMeshPro), typeof(TextMeshProUGUI) } }, + { DOTweenAnimationType.Fade, new[] { typeof(TextMeshPro), typeof(TextMeshProUGUI) } }, + { DOTweenAnimationType.Text, new[] { typeof(TextMeshPro), typeof(TextMeshProUGUI) } } + }; +#endif + + static readonly string[] _AnimationType = new[] { + "None", + "Move", "LocalMove", + "Rotate", "LocalRotate", + "Scale", + "Color", "Fade", + "Text", + "Punch/Position", "Punch/Rotation", "Punch/Scale", + "Shake/Position", "Shake/Rotation", "Shake/Scale", + "Camera/Aspect", "Camera/BackgroundColor", "Camera/FieldOfView", "Camera/OrthoSize", "Camera/PixelRect", "Camera/Rect" + }; + static string[] _animationTypeNoSlashes; // _AnimationType list without slashes in values + static string[] _datString; // String representation of DOTweenAnimation enum (here for caching reasons) + + DOTweenAnimation _src; + bool _runtimeEditMode; // If TRUE allows to change and save stuff at runtime + int _totComponentsOnSrc; // Used to determine if a Component is added or removed from the source + + // =================================================================================== + // MONOBEHAVIOUR METHODS ------------------------------------------------------------- + + void OnEnable() + { + _src = target as DOTweenAnimation; + + onStartProperty = base.serializedObject.FindProperty("onStart"); + onPlayProperty = base.serializedObject.FindProperty("onPlay"); + onUpdateProperty = base.serializedObject.FindProperty("onUpdate"); + onStepCompleteProperty = base.serializedObject.FindProperty("onStepComplete"); + onCompleteProperty = base.serializedObject.FindProperty("onComplete"); + + // Convert _AnimationType to _animationTypeNoSlashes + int len = _AnimationType.Length; + _animationTypeNoSlashes = new string[len]; + for (int i = 0; i < len; ++i) { + string a = _AnimationType[i]; + a = a.Replace("/", ""); + _animationTypeNoSlashes[i] = a; + } + } + + override public void OnInspectorGUI() + { + base.OnInspectorGUI(); + + GUILayout.Space(3); + EditorGUIUtils.SetGUIStyles(); + + bool playMode = Application.isPlaying; + _runtimeEditMode = _runtimeEditMode && playMode; + + GUILayout.BeginHorizontal(); + EditorGUIUtils.InspectorLogo(); + GUILayout.Label(_src.animationType.ToString() + (string.IsNullOrEmpty(_src.id) ? "" : " [" + _src.id + "]"), EditorGUIUtils.sideLogoIconBoldLabelStyle); + // Up-down buttons + GUILayout.FlexibleSpace(); + if (GUILayout.Button("▲", DeGUI.styles.button.toolIco)) UnityEditorInternal.ComponentUtility.MoveComponentUp(_src); + if (GUILayout.Button("▼", DeGUI.styles.button.toolIco)) UnityEditorInternal.ComponentUtility.MoveComponentDown(_src); + GUILayout.EndHorizontal(); + + if (playMode) { + if (_runtimeEditMode) { + + } else { + GUILayout.Space(8); + GUILayout.Label("Animation Editor disabled while in play mode", EditorGUIUtils.wordWrapLabelStyle); + if (!_src.isActive) { + GUILayout.Label("This animation has been toggled as inactive and won't be generated", EditorGUIUtils.wordWrapLabelStyle); + GUI.enabled = false; + } + if (GUILayout.Button(new GUIContent("Activate Edit Mode", "Switches to Runtime Edit Mode, where you can change animations values and restart them"))) { + _runtimeEditMode = true; + } + GUILayout.Label("NOTE: when using DOPlayNext, the sequence is determined by the DOTweenAnimation Components order in the target GameObject's Inspector", EditorGUIUtils.wordWrapLabelStyle); + GUILayout.Space(10); + if (!_runtimeEditMode) return; + } + } + + Undo.RecordObject(_src, "DOTween Animation"); + +// _src.isValid = Validate(); // Moved down + + EditorGUIUtility.labelWidth = 120; + + if (playMode) { + GUILayout.Space(4); + DeGUILayout.Toolbar("Edit Mode Commands"); + DeGUILayout.BeginVBox(DeGUI.styles.box.stickyTop); + GUILayout.BeginHorizontal(); + if (GUILayout.Button("TogglePause")) _src.tween.TogglePause(); + if (GUILayout.Button("Rewind")) _src.tween.Rewind(); + if (GUILayout.Button("Restart")) _src.tween.Restart(); + GUILayout.EndHorizontal(); + if (GUILayout.Button("Commit changes and restart")) { + _src.tween.Rewind(); + _src.tween.Kill(); + if (_src.isValid) { + _src.CreateTween(); + _src.tween.Play(); + } + } + GUILayout.Label("To apply your changes when exiting Play mode, use the Component's upper right menu and choose \"Copy Component\", then \"Paste Component Values\" after exiting Play mode", DeGUI.styles.label.wordwrap); + DeGUILayout.EndVBox(); + } else { + bool hasManager = _src.GetComponent<DOTweenVisualManager>() != null; + if (!hasManager) { + if (GUILayout.Button(new GUIContent("Add Manager", "Adds a manager component which allows you to choose additional options for this gameObject"))) { + _src.gameObject.AddComponent<DOTweenVisualManager>(); + } + } + } + + GUILayout.BeginHorizontal(); + DOTweenAnimationType prevAnimType = _src.animationType; +// _src.animationType = (DOTweenAnimationType)EditorGUILayout.EnumPopup(_src.animationType, EditorGUIUtils.popupButton); + _src.isActive = EditorGUILayout.Toggle(new GUIContent("", "If unchecked, this animation will not be created"), _src.isActive, GUILayout.Width(16)); + GUI.enabled = _src.isActive; + _src.animationType = AnimationToDOTweenAnimationType(_AnimationType[EditorGUILayout.Popup(DOTweenAnimationTypeToPopupId(_src.animationType), _AnimationType)]); + _src.autoPlay = DeGUILayout.ToggleButton(_src.autoPlay, new GUIContent("AutoPlay", "If selected, the tween will play automatically")); + _src.autoKill = DeGUILayout.ToggleButton(_src.autoKill, new GUIContent("AutoKill", "If selected, the tween will be killed when it completes, and won't be reusable")); + GUILayout.EndHorizontal(); + if (prevAnimType != _src.animationType) { + // Set default optional values based on animation type + switch (_src.animationType) { + case DOTweenAnimationType.Move: + case DOTweenAnimationType.LocalMove: + case DOTweenAnimationType.Rotate: + case DOTweenAnimationType.LocalRotate: + case DOTweenAnimationType.Scale: + _src.endValueV3 = Vector3.zero; + _src.endValueFloat = 0; + _src.optionalBool0 = _src.animationType == DOTweenAnimationType.Scale; + break; + case DOTweenAnimationType.Color: + case DOTweenAnimationType.Fade: + _src.endValueFloat = 0; + break; + case DOTweenAnimationType.Text: + _src.optionalBool0 = true; + break; + case DOTweenAnimationType.PunchPosition: + case DOTweenAnimationType.PunchRotation: + case DOTweenAnimationType.PunchScale: + _src.endValueV3 = _src.animationType == DOTweenAnimationType.PunchRotation ? new Vector3(0,180,0) : Vector3.one; + _src.optionalFloat0 = 1; + _src.optionalInt0 = 10; + _src.optionalBool0 = false; + break; + case DOTweenAnimationType.ShakePosition: + case DOTweenAnimationType.ShakeRotation: + case DOTweenAnimationType.ShakeScale: + _src.endValueV3 = _src.animationType == DOTweenAnimationType.ShakeRotation ? new Vector3(90,90,90) : Vector3.one; + _src.optionalInt0 = 10; + _src.optionalFloat0 = 90; + _src.optionalBool0 = false; + break; + case DOTweenAnimationType.CameraAspect: + case DOTweenAnimationType.CameraFieldOfView: + case DOTweenAnimationType.CameraOrthoSize: + _src.endValueFloat = 0; + break; + case DOTweenAnimationType.CameraPixelRect: + case DOTweenAnimationType.CameraRect: + _src.endValueRect = new Rect(0, 0, 0, 0); + break; + } + } + if (_src.animationType == DOTweenAnimationType.None) { + _src.isValid = false; + if (GUI.changed) EditorUtility.SetDirty(_src); + return; + } + + if (prevAnimType != _src.animationType || ComponentsChanged()) { + _src.isValid = Validate(); + } + + if (!_src.isValid) { + GUI.color = Color.red; + GUILayout.BeginVertical(GUI.skin.box); + GUILayout.Label("No valid Component was found for the selected animation", EditorGUIUtils.wordWrapLabelStyle); + GUILayout.EndVertical(); + GUI.color = Color.white; + if (GUI.changed) EditorUtility.SetDirty(_src); + return; + } + + _src.duration = EditorGUILayout.FloatField("Duration", _src.duration); + if (_src.duration < 0) _src.duration = 0; + _src.delay = EditorGUILayout.FloatField("Delay", _src.delay); + if (_src.delay < 0) _src.delay = 0; + _src.isIndependentUpdate = EditorGUILayout.Toggle("Ignore TimeScale", _src.isIndependentUpdate); + _src.easeType = EditorGUIUtils.FilteredEasePopup(_src.easeType); + if (_src.easeType == Ease.INTERNAL_Custom) { + _src.easeCurve = EditorGUILayout.CurveField(" Ease Curve", _src.easeCurve); + } + _src.loops = EditorGUILayout.IntField(new GUIContent("Loops", "Set to -1 for infinite loops"), _src.loops); + if (_src.loops < -1) _src.loops = -1; + if (_src.loops > 1 || _src.loops == -1) + _src.loopType = (LoopType)EditorGUILayout.EnumPopup(" Loop Type", _src.loopType); + _src.id = EditorGUILayout.TextField("ID", _src.id); + + bool canBeRelative = true; + // End value and eventual specific options + switch (_src.animationType) { + case DOTweenAnimationType.Move: + case DOTweenAnimationType.LocalMove: + GUIEndValueV3(); + _src.optionalBool0 = EditorGUILayout.Toggle(" Snapping", _src.optionalBool0); + break; + case DOTweenAnimationType.Rotate: + case DOTweenAnimationType.LocalRotate: + if (_src.GetComponent<Rigidbody2D>()) GUIEndValueFloat(); + else { + GUIEndValueV3(); + _src.optionalRotationMode = (RotateMode)EditorGUILayout.EnumPopup(" Rotation Mode", _src.optionalRotationMode); + } + break; + case DOTweenAnimationType.Scale: + if (_src.optionalBool0) GUIEndValueFloat(); + else GUIEndValueV3(); + _src.optionalBool0 = EditorGUILayout.Toggle("Uniform Scale", _src.optionalBool0); + break; + case DOTweenAnimationType.Color: + GUIEndValueColor(); + canBeRelative = false; + break; + case DOTweenAnimationType.Fade: + GUIEndValueFloat(); + if (_src.endValueFloat < 0) _src.endValueFloat = 0; + if (_src.endValueFloat > 1) _src.endValueFloat = 1; + canBeRelative = false; + break; + case DOTweenAnimationType.Text: + GUIEndValueString(); + _src.optionalBool0 = EditorGUILayout.Toggle("Rich Text Enabled", _src.optionalBool0); + _src.optionalScrambleMode = (ScrambleMode)EditorGUILayout.EnumPopup("Scramble Mode", _src.optionalScrambleMode); + _src.optionalString = EditorGUILayout.TextField(new GUIContent("Custom Scramble", "Custom characters to use in case of ScrambleMode.Custom"), _src.optionalString); + break; + case DOTweenAnimationType.PunchPosition: + case DOTweenAnimationType.PunchRotation: + case DOTweenAnimationType.PunchScale: + GUIEndValueV3(); + canBeRelative = false; + _src.optionalInt0 = EditorGUILayout.IntSlider(new GUIContent(" Vibrato", "How much will the punch vibrate"), _src.optionalInt0, 1, 50); + _src.optionalFloat0 = EditorGUILayout.Slider(new GUIContent(" Elasticity", "How much the vector will go beyond the starting position when bouncing backwards"), _src.optionalFloat0, 0, 1); + if (_src.animationType == DOTweenAnimationType.PunchPosition) _src.optionalBool0 = EditorGUILayout.Toggle(" Snapping", _src.optionalBool0); + break; + case DOTweenAnimationType.ShakePosition: + case DOTweenAnimationType.ShakeRotation: + case DOTweenAnimationType.ShakeScale: + GUIEndValueV3(); + canBeRelative = false; + _src.optionalInt0 = EditorGUILayout.IntSlider(new GUIContent(" Vibrato", "How much will the shake vibrate"), _src.optionalInt0, 1, 50); + _src.optionalFloat0 = EditorGUILayout.Slider(new GUIContent(" Randomness", "The shake randomness"), _src.optionalFloat0, 0, 90); + if (_src.animationType == DOTweenAnimationType.ShakePosition) _src.optionalBool0 = EditorGUILayout.Toggle(" Snapping", _src.optionalBool0); + break; + case DOTweenAnimationType.CameraAspect: + case DOTweenAnimationType.CameraFieldOfView: + case DOTweenAnimationType.CameraOrthoSize: + GUIEndValueFloat(); + canBeRelative = false; + break; + case DOTweenAnimationType.CameraBackgroundColor: + GUIEndValueColor(); + canBeRelative = false; + break; + case DOTweenAnimationType.CameraPixelRect: + case DOTweenAnimationType.CameraRect: + GUIEndValueRect(); + canBeRelative = false; + break; + } + + // Final settings + if (canBeRelative) _src.isRelative = EditorGUILayout.Toggle(" Relative", _src.isRelative); + + // Events + AnimationInspectorGUI.AnimationEvents(this, _src); + + if (GUI.changed) EditorUtility.SetDirty(_src); + } + + // Returns TRUE if the Component layout on the src gameObject changed (a Component was added or removed) + bool ComponentsChanged() + { + int prevTotComponentsOnSrc = _totComponentsOnSrc; + _totComponentsOnSrc = _src.gameObject.GetComponents<Component>().Length; + return prevTotComponentsOnSrc != _totComponentsOnSrc; + } + + // Checks if a Component that can be animated with the given animationType is attached to the src + bool Validate() + { + if (_src.animationType == DOTweenAnimationType.None) return false; + + Component srcTarget; + // First check for external plugins +#if DOTWEEN_TK2D + if (_Tk2dAnimationTypeToComponent.ContainsKey(_src.animationType)) { + foreach (Type t in _Tk2dAnimationTypeToComponent[_src.animationType]) { + srcTarget = _src.GetComponent(t); + if (srcTarget != null) { + _src.target = srcTarget; + return true; + } + } + } +#endif +#if DOTWEEN_TMP + if (_TMPAnimationTypeToComponent.ContainsKey(_src.animationType)) { + foreach (Type t in _TMPAnimationTypeToComponent[_src.animationType]) { + srcTarget = _src.GetComponent(t); + if (srcTarget != null) { + _src.target = srcTarget; + return true; + } + } + } +#endif + // Then check for regular stuff + if (_AnimationTypeToComponent.ContainsKey(_src.animationType)) { + foreach (Type t in _AnimationTypeToComponent[_src.animationType]) { + srcTarget = _src.GetComponent(t); + if (srcTarget != null) { + _src.target = srcTarget; + return true; + } + } + } + return false; + } + + DOTweenAnimationType AnimationToDOTweenAnimationType(string animation) + { + if (_datString == null) _datString = Enum.GetNames(typeof(DOTweenAnimationType)); + animation = animation.Replace("/", ""); + return (DOTweenAnimationType)(Array.IndexOf(_datString, animation)); + } + int DOTweenAnimationTypeToPopupId(DOTweenAnimationType animation) + { + return Array.IndexOf(_animationTypeNoSlashes, animation.ToString()); + } + + void GUIEndValueFloat() + { + GUILayout.BeginHorizontal(); + GUIToFromButton(); + _src.endValueFloat = EditorGUILayout.FloatField(_src.endValueFloat); + GUILayout.EndHorizontal(); + } + + void GUIEndValueColor() + { + GUILayout.BeginHorizontal(); + GUIToFromButton(); + _src.endValueColor = EditorGUILayout.ColorField(_src.endValueColor); + GUILayout.EndHorizontal(); + } + + void GUIEndValueV3() + { + GUILayout.BeginHorizontal(); + GUIToFromButton(); + _src.endValueV3 = EditorGUILayout.Vector3Field("", _src.endValueV3, GUILayout.Height(16)); + GUILayout.EndHorizontal(); + } + + void GUIEndValueString() + { + GUILayout.BeginHorizontal(); + GUIToFromButton(); + _src.endValueString = EditorGUILayout.TextArea(_src.endValueString, EditorGUIUtils.wordWrapTextArea); + GUILayout.EndHorizontal(); + } + + void GUIEndValueRect() + { + GUILayout.BeginHorizontal(); + GUIToFromButton(); + _src.endValueRect = EditorGUILayout.RectField(_src.endValueRect); + GUILayout.EndHorizontal(); + } + + void GUIToFromButton() + { + if (GUILayout.Button(_src.isFrom ? "FROM" : "TO", EditorGUIUtils.sideBtStyle, GUILayout.Width(100))) _src.isFrom = !_src.isFrom; + GUILayout.Space(16); + } + } +}
\ No newline at end of file diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenAnimationInspector.cs.meta b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenAnimationInspector.cs.meta new file mode 100644 index 00000000..d2d7eee1 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenAnimationInspector.cs.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: e0203fd81362bab4d842d87ad09ee76e +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.XML b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.XML new file mode 100644 index 00000000..ad80aef0 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.XML @@ -0,0 +1,18 @@ +<?xml version="1.0"?> +<doc> + <assembly> + <name>DOTweenProEditor</name> + </assembly> + <members> + <member name="T:DG.DOTweenEditor.Core.ColorPalette.Custom"> + <summary> + Custom colors + </summary> + </member> + <member name="M:DG.DOTweenEditor.Core.StylePalette.Custom.Init"> + <summary> + Needs to be overridden in order to initialize new styles added from inherited classes + </summary> + </member> + </members> +</doc> diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.XML.meta b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.XML.meta new file mode 100644 index 00000000..f37a1335 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.XML.meta @@ -0,0 +1,4 @@ +fileFormatVersion: 2 +guid: 753a4f4ed73b17143923101226957756 +TextScriptImporter: + userData: diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll Binary files differnew file mode 100644 index 00000000..0514c557 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.mdb b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.mdb Binary files differnew file mode 100644 index 00000000..d97479df --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.mdb diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.mdb.meta b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.mdb.meta new file mode 100644 index 00000000..f7149bc2 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.mdb.meta @@ -0,0 +1,4 @@ +fileFormatVersion: 2 +guid: ee3a420017f129443896310d9fab256b +DefaultImporter: + userData: diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.meta b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.meta new file mode 100644 index 00000000..1eeec600 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.meta @@ -0,0 +1,33 @@ +fileFormatVersion: 2 +guid: a6402d4311c862b4eb1325590d6466af +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + Any: + second: + enabled: 0 + settings: {} + - first: + Editor: Editor + second: + enabled: 1 + settings: + DefaultValueInitialized: true + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/readme.txt b/Assets/ThirdParty/Demigiant/DOTweenPro/readme.txt new file mode 100644 index 00000000..50f25c71 --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/readme.txt @@ -0,0 +1,25 @@ +DOTween and DOTween Pro are copyright (c) 2014 Daniele Giardini - Demigiant + +// GET STARTED ////////////////////////////////////////////// + +- After importing a new DOTween update, select DOTween's Utility Panel from the Tools menu (if it doesn't open automatically) and press the "Setup DOTween..." button to set up additional features based on your Unity version. +Do this AFTER you have imported other plugins, so they will be recognized and if DOTween has additional features for those plugins they will be imported. + +// VISUAL SCRIPTING (PRO ONLY) +- To animate a gameObject, select it and choose "Add Component > DOTween > DOTween Animation" +- To animate a gameObject along a path, select it and choose "Add Component > DOTween > DOTween Path" + +// SCRIPTING +- 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/ + +// NOTES ////////////////////////////////////////////////////// + +- DOTween's Utility Panel can be found under "Tools > DOTween Utility Panel" and also contains other useful options, plus a tab to set DOTween's preferences
\ No newline at end of file diff --git a/Assets/ThirdParty/Demigiant/DOTweenPro/readme.txt.meta b/Assets/ThirdParty/Demigiant/DOTweenPro/readme.txt.meta new file mode 100644 index 00000000..6a87c35d --- /dev/null +++ b/Assets/ThirdParty/Demigiant/DOTweenPro/readme.txt.meta @@ -0,0 +1,4 @@ +fileFormatVersion: 2 +guid: aa8f07903bf128e44a7d0b91a63dedab +TextScriptImporter: + userData: |