//namespace DentedPixel{
using System;
using UnityEngine;

/**
* Internal Representation of a Tween<br>
* <br>
* This class represents all of the optional parameters you can pass to a method (it also represents the internal representation of the tween).<br><br>
* <strong id='optional'>Optional Parameters</strong> are passed at the end of every method:<br> 
* <br>
* &nbsp;&nbsp;<i>Example:</i><br>
* &nbsp;&nbsp;LeanTween.moveX( gameObject, 1f, 1f).setEase( <a href="LeanTweenType.html">LeanTweenType</a>.easeInQuad ).setDelay(1f);<br>
* <br>
* You can pass the optional parameters in any order, and chain on as many as you wish.<br>
* You can also <strong>pass parameters at a later time</strong> by saving a reference to what is returned.<br>
* <br>
* Retrieve a <strong>unique id</strong> for the tween by using the "id" property. You can pass this to LeanTween.pause, LeanTween.resume, LeanTween.cancel, LeanTween.isTweening methods<br>
* <br>
* &nbsp;&nbsp;<h4>Example:</h4>
* &nbsp;&nbsp;int id = LeanTween.moveX(gameObject, 1f, 3f).id;<br>
* <div style="color:gray">&nbsp;&nbsp;// pause a specific tween</div>
* &nbsp;&nbsp;LeanTween.pause(id);<br>
* <div style="color:gray">&nbsp;&nbsp;// resume later</div>
* &nbsp;&nbsp;LeanTween.resume(id);<br>
* <div style="color:gray">&nbsp;&nbsp;// check if it is tweening before kicking of a new tween</div>
* &nbsp;&nbsp;if( LeanTween.isTweening( id ) ){<br>
* &nbsp;&nbsp; &nbsp;&nbsp;	LeanTween.cancel( id );<br>
* &nbsp;&nbsp; &nbsp;&nbsp;	LeanTween.moveZ(gameObject, 10f, 3f);<br>
* &nbsp;&nbsp;}<br>
* @class LTDescr
* @constructor
*/

namespace GameLogic
{

    public class LTDescr
    {
        public bool toggle;
        public bool useEstimatedTime;
        public bool useFrames;
        public bool useManualTime;
        public bool usesNormalDt;
        public bool hasInitiliazed;
        public bool hasExtraOnCompletes;
        public bool hasPhysics;
        public bool onCompleteOnRepeat;
        public bool onCompleteOnStart;
        public bool useRecursion;
        public float ratioPassed;
        public float passed;
        public float delay;
        public float time;
        public float speed;
        public float lastVal;
        private uint _id;
        public int loopCount;
        public uint counter = uint.MaxValue;
        public float direction;
        public float directionLast;
        public float overshoot;
        public float period;
        public float scale;
        public bool destroyOnComplete;
        public Transform trans;
        internal Vector3 fromInternal;

        public Vector3 from
        {
            get { return this.fromInternal; }
            set { this.fromInternal = value; }
        }

        internal Vector3 toInternal;

        public Vector3 to
        {
            get { return this.toInternal; }
            set { this.toInternal = value; }
        }

        internal Vector3 diff;
        internal Vector3 diffDiv2;
        public TweenAction type;
        private LeanTweenType easeType;
        public LeanTweenType loopType;

        public bool hasUpdateCallback;

        public EaseTypeDelegate easeMethod;
        public ActionMethodDelegate easeInternal { get; set; }
        public ActionMethodDelegate initInternal { get; set; }

        public delegate Vector3 EaseTypeDelegate();

        public delegate void ActionMethodDelegate();

#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
        public SpriteRenderer spriteRen;
#endif

#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
        public RectTransform rectTransform;
        public UnityEngine.UI.Text uiText;
        public UnityEngine.UI.Image uiImage;
        public UnityEngine.UI.RawImage rawImage;
        public UnityEngine.Sprite[] sprites;
#endif

        public LTDescrOptional _optional = new LTDescrOptional();

        public override string ToString()
        {
            return (trans != null ? "name:" + trans.gameObject.name : "gameObject:null") + " toggle:" + toggle +
                   " passed:" + passed + " time:" + time + " delay:" + delay + " direction:" + direction + " from:" +
                   from + " to:" + to + " diff:" + diff + " type:" + type + " ease:" + easeType + " useEstimatedTime:" +
                   useEstimatedTime + " id:" + id + " hasInitiliazed:" + hasInitiliazed;
        }

        public LTDescr()
        {

        }

        [System.Obsolete("Use 'LeanTween.cancel( id )' instead")]
        public LTDescr cancel(GameObject gameObject)
        {
            // Debug.Log("canceling id:"+this._id+" this.uniqueId:"+this.uniqueId+" go:"+this.trans.gameObject);
            if (gameObject == this.trans.gameObject)
                LeanTween.removeTween((int) this._id, this.uniqueId);
            return this;
        }

        public int uniqueId
        {
            get
            {
                uint toId = _id | counter << 16;

                /*uint backId = toId & 0xFFFF;
			uint backCounter = toId >> 16;
			if(_id!=backId || backCounter!=counter){
				Debug.LogError("BAD CONVERSION toId:"+_id);
			}*/

                return (int) toId;
            }
        }

        public int id
        {
            get { return uniqueId; }
        }

        public LTDescrOptional optional
        {
            get { return _optional; }
            set { this._optional = value; }
        }

        public void reset()
        {
            this.toggle = this.useRecursion = this.usesNormalDt = true;
            this.trans = null;
            this.spriteRen = null;
            this.passed = this.delay = this.lastVal = 0.0f;
            this.hasUpdateCallback =
                this.useEstimatedTime =
                    this.useFrames =
                        this.hasInitiliazed =
                            this.onCompleteOnRepeat =
                                this.destroyOnComplete =
                                    this.onCompleteOnStart = this.useManualTime = this.hasExtraOnCompletes = false;
            this.easeType = LeanTweenType.linear;
            this.loopType = LeanTweenType.once;
            this.loopCount = 0;
            this.direction = this.directionLast = this.overshoot = this.scale = 1.0f;
            this.period = 0.3f;
            this.speed = -1f;
            this.easeMethod = this.easeLinear;
            this.from = this.to = Vector3.zero;
            this._optional.reset();


        }

        // Initialize and Internal Methods

        public LTDescr setMoveX()
        {
            this.type = TweenAction.MOVE_X;
            this.initInternal = () => { this.fromInternal.x = trans.position.x; };
            this.easeInternal =
                () => { trans.position = new Vector3(easeMethod().x, trans.position.y, trans.position.z); };
            return this;
        }

        public LTDescr setMoveY()
        {
            this.type = TweenAction.MOVE_Y;
            this.initInternal = () => { this.fromInternal.x = trans.position.y; };
            this.easeInternal =
                () => { trans.position = new Vector3(trans.position.x, easeMethod().x, trans.position.z); };
            return this;
        }

        public LTDescr setMoveZ()
        {
            this.type = TweenAction.MOVE_Z;
            this.initInternal = () => { this.fromInternal.x = trans.position.z; };
            ;
            this.easeInternal =
                () => { trans.position = new Vector3(trans.position.x, trans.position.y, easeMethod().x); };
            return this;
        }

        public LTDescr setMoveLocalX()
        {
            this.type = TweenAction.MOVE_LOCAL_X;
            this.initInternal = () => { this.fromInternal.x = trans.localPosition.x; };
            this.easeInternal =
                () =>
                {
                    trans.localPosition = new Vector3(easeMethod().x, trans.localPosition.y, trans.localPosition.z);
                };
            return this;
        }

        public LTDescr setMoveLocalY()
        {
            this.type = TweenAction.MOVE_LOCAL_Y;
            this.initInternal = () => { this.fromInternal.x = trans.localPosition.y; };
            this.easeInternal =
                () =>
                {
                    trans.localPosition = new Vector3(trans.localPosition.x, easeMethod().x, trans.localPosition.z);
                };
            return this;
        }

        public LTDescr setMoveLocalZ()
        {
            this.type = TweenAction.MOVE_LOCAL_Z;
            this.initInternal = () => { this.fromInternal.x = trans.localPosition.z; };
            this.easeInternal =
                () =>
                {
                    trans.localPosition = new Vector3(trans.localPosition.x, trans.localPosition.y, easeMethod().x);
                };
            return this;
        }

        private void initFromInternal()
        {
            this.fromInternal.x = 0;
        }

        public LTDescr setMoveCurved()
        {
            this.type = TweenAction.MOVE_CURVED;
            this.initInternal = this.initFromInternal;
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                if (this._optional.path.orientToPath)
                {
                    if (this._optional.path.orientToPath2d)
                    {
                        this._optional.path.place2d(trans, val);
                    }
                    else
                    {
                        this._optional.path.place(trans, val);
                    }
                }
                else
                {
                    trans.position = this._optional.path.point(val);
                }
            };
            return this;
        }

        public LTDescr setMoveCurvedLocal()
        {
            this.type = TweenAction.MOVE_CURVED_LOCAL;
            this.initInternal = this.initFromInternal;
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                if (this._optional.path.orientToPath)
                {
                    if (this._optional.path.orientToPath2d)
                    {
                        this._optional.path.placeLocal2d(trans, val);
                    }
                    else
                    {
                        this._optional.path.placeLocal(trans, val);
                    }
                }
                else
                {
                    trans.localPosition = this._optional.path.point(val);
                }
            };
            return this;
        }

        public LTDescr setMoveSpline()
        {
            this.type = TweenAction.MOVE_SPLINE;
            this.initInternal = this.initFromInternal;
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                if (this._optional.spline.orientToPath)
                {
                    if (this._optional.spline.orientToPath2d)
                    {
                        this._optional.spline.place2d(trans, val);
                    }
                    else
                    {
                        this._optional.spline.place(trans, val);
                    }
                }
                else
                {
                    trans.position = this._optional.spline.point(val);
                }
            };
            return this;
        }

        public LTDescr setMoveSplineLocal()
        {
            this.type = TweenAction.MOVE_SPLINE_LOCAL;
            this.initInternal = this.initFromInternal;
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                if (this._optional.spline.orientToPath)
                {
                    if (this._optional.spline.orientToPath2d)
                    {
                        this._optional.spline.placeLocal2d(trans, val);
                    }
                    else
                    {
                        this._optional.spline.placeLocal(trans, val);
                    }
                }
                else
                {
                    trans.localPosition = this._optional.spline.point(val);
                }
            };
            return this;
        }

        public LTDescr setScaleX()
        {
            this.type = TweenAction.SCALE_X;
            this.initInternal = () => { this.fromInternal.x = trans.localScale.x; };
            this.easeInternal =
                () => { trans.localScale = new Vector3(easeMethod().x, trans.localScale.y, trans.localScale.z); };
            return this;
        }

        public LTDescr setScaleY()
        {
            this.type = TweenAction.SCALE_Y;
            this.initInternal = () => { this.fromInternal.x = trans.localScale.y; };
            this.easeInternal =
                () => { trans.localScale = new Vector3(trans.localScale.x, easeMethod().x, trans.localScale.z); };
            return this;
        }

        public LTDescr setScaleZ()
        {
            this.type = TweenAction.SCALE_Z;
            this.initInternal = () => { this.fromInternal.x = trans.localScale.z; };
            this.easeInternal =
                () => { trans.localScale = new Vector3(trans.localScale.x, trans.localScale.y, easeMethod().x); };
            return this;
        }

        public LTDescr setRotateX()
        {
            this.type = TweenAction.ROTATE_X;
            this.initInternal = () =>
            {
                this.fromInternal.x = trans.eulerAngles.x;
                this.toInternal.x = LeanTween.closestRot(this.fromInternal.x, this.toInternal.x);
            };
            this.easeInternal =
                () => { trans.eulerAngles = new Vector3(easeMethod().x, trans.eulerAngles.y, trans.eulerAngles.z); };
            return this;
        }

        public LTDescr setRotateY()
        {
            this.type = TweenAction.ROTATE_Y;
            this.initInternal = () =>
            {
                this.fromInternal.x = trans.eulerAngles.y;
                this.toInternal.x = LeanTween.closestRot(this.fromInternal.x, this.toInternal.x);
            };
            this.easeInternal =
                () => { trans.eulerAngles = new Vector3(trans.eulerAngles.x, easeMethod().x, trans.eulerAngles.z); };
            return this;
        }

        public LTDescr setRotateZ()
        {
            this.type = TweenAction.ROTATE_Z;
            this.initInternal = () =>
            {
                this.fromInternal.x = trans.eulerAngles.z;
                this.toInternal.x = LeanTween.closestRot(this.fromInternal.x, this.toInternal.x);
            };
            this.easeInternal =
                () => { trans.eulerAngles = new Vector3(trans.eulerAngles.x, trans.eulerAngles.y, easeMethod().x); };
            return this;
        }

        public LTDescr setRotateAround()
        {
            this.type = TweenAction.ROTATE_AROUND;
            this.initInternal = () =>
            {
                this.fromInternal.x = 0f;
                this._optional.origRotation = trans.rotation;
            };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                Vector3 origPos = trans.localPosition;
                Vector3 rotateAroundPt = (Vector3) trans.TransformPoint(this._optional.point);
                // Debug.Log("this._optional.point:"+this._optional.point);
                trans.RotateAround(rotateAroundPt, this._optional.axis, -this._optional.lastVal);
                Vector3 diff = origPos - trans.localPosition;

                trans.localPosition = origPos - diff;
                    // Subtract the amount the object has been shifted over by the rotate, to get it back to it's orginal position
                trans.rotation = this._optional.origRotation;

                rotateAroundPt = (Vector3) trans.TransformPoint(this._optional.point);
                trans.RotateAround(rotateAroundPt, this._optional.axis, val);

                this._optional.lastVal = val;
            };
            return this;
        }

        public LTDescr setRotateAroundLocal()
        {
            this.type = TweenAction.ROTATE_AROUND_LOCAL;
            this.initInternal = () =>
            {
                this.fromInternal.x = 0f;
                this._optional.origRotation = trans.localRotation;
            };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                Vector3 origPos = trans.localPosition;
                trans.RotateAround((Vector3) trans.TransformPoint(this._optional.point),
                    trans.TransformDirection(this._optional.axis), -this._optional.lastVal);
                Vector3 diff = origPos - trans.localPosition;

                trans.localPosition = origPos - diff;
                    // Subtract the amount the object has been shifted over by the rotate, to get it back to it's orginal position
                trans.localRotation = this._optional.origRotation;
                Vector3 rotateAroundPt = (Vector3) trans.TransformPoint(this._optional.point);
                trans.RotateAround(rotateAroundPt, trans.TransformDirection(this._optional.axis), val);

                this._optional.lastVal = val;
            };
            return this;
        }

        public LTDescr setAlpha()
        {
            this.type = TweenAction.ALPHA;
            this.initInternal = () =>
            {
#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
			if(trans.gameObject.renderer){ this.fromInternal.x = trans.gameObject.renderer.material.color.a; }else if(trans.childCount>0){ foreach (Transform child in trans) { if(child.gameObject.renderer!=null){ Color col = child.gameObject.renderer.material.color; this.fromInternal.x = col.a; break; }}}
			this.easeInternal = this.alpha;
			break;	
			#else
                SpriteRenderer ren = trans.GetComponent<SpriteRenderer>();
                if (ren != null)
                {
                    this.fromInternal.x = ren.color.a;
                }
                else
                {
                    if (trans.GetComponent<Renderer>() != null &&
                        trans.GetComponent<Renderer>().material.HasProperty("_Color"))
                    {
                        this.fromInternal.x = trans.GetComponent<Renderer>().material.color.a;
                    }
                    else if (trans.GetComponent<Renderer>() != null &&
                             trans.GetComponent<Renderer>().material.HasProperty("_TintColor"))
                    {
                        Color col = trans.GetComponent<Renderer>().material.GetColor("_TintColor");
                        this.fromInternal.x = col.a;
                    }
                    else if (trans.childCount > 0)
                    {
                        foreach (Transform child in trans)
                        {
                            if (child.gameObject.GetComponent<Renderer>() != null)
                            {
                                Color col = child.gameObject.GetComponent<Renderer>().material.color;
                                this.fromInternal.x = col.a;
                                break;
                            }
                        }
                    }
                }
#endif

                this.easeInternal = () =>
                {
                    val = easeMethod().x;
#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
				alphaRecursive(this.trans, val, this.useRecursion);
				#else
                    if (this.spriteRen != null)
                    {
                        this.spriteRen.color = new Color(this.spriteRen.color.r, this.spriteRen.color.g,
                            this.spriteRen.color.b, val);
                        alphaRecursiveSprite(this.trans, val);
                    }
                    else
                    {
                        alphaRecursive(this.trans, val, this.useRecursion);
                    }
#endif
                };

            };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
			alphaRecursive(this.trans, val, this.useRecursion);
			#else
                if (this.spriteRen != null)
                {
                    this.spriteRen.color = new Color(this.spriteRen.color.r, this.spriteRen.color.g,
                        this.spriteRen.color.b, val);
                    alphaRecursiveSprite(this.trans, val);
                }
                else
                {
                    alphaRecursive(this.trans, val, this.useRecursion);
                }
#endif
            };
            return this;
        }

        public LTDescr setTextAlpha()
        {
            this.type = TweenAction.TEXT_ALPHA;
            this.initInternal = () =>
            {
                this.uiText = trans.GetComponent<UnityEngine.UI.Text>();
                this.fromInternal.x = this.uiText != null ? this.uiText.color.a : 1f;
            };
            this.easeInternal = () => { textAlphaRecursive(trans, easeMethod().x, this.useRecursion); };
            return this;
        }

        public LTDescr setAlphaVertex()
        {
            this.type = TweenAction.ALPHA_VERTEX;
            this.initInternal = () => { this.fromInternal.x = trans.GetComponent<MeshFilter>().mesh.colors32[0].a; };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                Mesh mesh = trans.GetComponent<MeshFilter>().mesh;
                Vector3[] vertices = mesh.vertices;
                Color32[] colors = new Color32[vertices.Length];
                if (colors.Length == 0)
                {
                    //MaxFW fix: add vertex colors if the mesh doesn't have any             
                    Color32 transparentWhiteColor32 = new Color32(0xff, 0xff, 0xff, 0x00);
                    colors = new Color32[mesh.vertices.Length];
                    for (int k = 0; k < colors.Length; k++)
                        colors[k] = transparentWhiteColor32;
                    mesh.colors32 = colors;
                } // fix end
                Color32 c = mesh.colors32[0];
                c = new Color(c.r, c.g, c.b, val);
                for (int k = 0; k < vertices.Length; k++)
                    colors[k] = c;
                mesh.colors32 = colors;
            };
            return this;
        }

        public LTDescr setColor()
        {
            this.type = TweenAction.COLOR;
            this.initInternal = () =>
            {
#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
			if(trans.gameObject.renderer){
			this.setFromColor( trans.gameObject.renderer.material.color );
			}else if(trans.childCount>0){
			foreach (Transform child in trans) {
			if(child.gameObject.renderer!=null){
			this.setFromColor( child.gameObject.renderer.material.color );
			break;
			}
			}
			}
			#else
                SpriteRenderer renColor = trans.GetComponent<SpriteRenderer>();
                if (renColor != null)
                {
                    this.setFromColor(renColor.color);
                }
                else
                {
                    if (trans.GetComponent<Renderer>() != null &&
                        trans.GetComponent<Renderer>().material.HasProperty("_Color"))
                    {
                        Color col = trans.GetComponent<Renderer>().material.color;
                        this.setFromColor(col);
                    }
                    else if (trans.GetComponent<Renderer>() != null &&
                             trans.GetComponent<Renderer>().material.HasProperty("_TintColor"))
                    {
                        Color col = trans.GetComponent<Renderer>().material.GetColor("_TintColor");
                        this.setFromColor(col);
                    }
                    else if (trans.childCount > 0)
                    {
                        foreach (Transform child in trans)
                        {
                            if (child.gameObject.GetComponent<Renderer>() != null)
                            {
                                Color col = child.gameObject.GetComponent<Renderer>().material.color;
                                this.setFromColor(col);
                                break;
                            }
                        }
                    }
                }
#endif
            };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                Color toColor = tweenColor(this, val);

#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2

                if (this.spriteRen != null)
                {
                    this.spriteRen.color = toColor;
                    colorRecursiveSprite(trans, toColor);
                }
                else
                {
#endif
                    // Debug.Log("val:"+val+" tween:"+tween+" tween.diff:"+tween.diff);
                    if (this.type == TweenAction.COLOR)
                        colorRecursive(trans, toColor, this.useRecursion);

#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
                }
#endif
                if (dt != 0f && this._optional.onUpdateColor != null)
                {
                    this._optional.onUpdateColor(toColor);
                }
                else if (dt != 0f && this._optional.onUpdateColorObject != null)
                {
                    this._optional.onUpdateColorObject(toColor, this._optional.onUpdateParam);
                }
            };
            return this;
        }

        public LTDescr setCallbackColor()
        {
            this.type = TweenAction.CALLBACK_COLOR;
            this.initInternal = () => { this.diff = new Vector3(1.0f, 0.0f, 0.0f); };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                Color toColor = tweenColor(this, val);

#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
                if (this.spriteRen != null)
                {
                    this.spriteRen.color = toColor;
                    colorRecursiveSprite(trans, toColor);
                }
                else
                {
#endif
                    // Debug.Log("val:"+val+" tween:"+tween+" tween.diff:"+tween.diff);
                    if (this.type == TweenAction.COLOR)
                        colorRecursive(trans, toColor, this.useRecursion);

#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
                }
#endif
                if (dt != 0f && this._optional.onUpdateColor != null)
                {
                    this._optional.onUpdateColor(toColor);
                }
                else if (dt != 0f && this._optional.onUpdateColorObject != null)
                {
                    this._optional.onUpdateColorObject(toColor, this._optional.onUpdateParam);
                }
            };
            return this;
        }


#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5

        public LTDescr setTextColor()
        {
            this.type = TweenAction.TEXT_COLOR;
            this.initInternal = () =>
            {
                this.uiText = trans.GetComponent<UnityEngine.UI.Text>();
                this.setFromColor(this.uiText != null ? this.uiText.color : Color.white);
            };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                Color toColor = tweenColor(this, val);
                this.uiText.color = toColor;
                if (dt != 0f && this._optional.onUpdateColor != null)
                    this._optional.onUpdateColor(toColor);

                if (this.useRecursion && trans.childCount > 0)
                    textColorRecursive(this.trans, toColor);
            };
            return this;
        }

        public LTDescr setCanvasAlpha()
        {
            this.type = TweenAction.CANVAS_ALPHA;
            this.initInternal = () =>
            {
                this.uiImage = trans.GetComponent<UnityEngine.UI.Image>();
                if (this.uiImage != null)
                {
                    this.fromInternal.x = this.uiImage.color.a;
                }
                else
                {
                    this.rawImage = trans.GetComponent<UnityEngine.UI.RawImage>();
                    if (this.rawImage != null)
                    {
                        this.fromInternal.x = this.rawImage.color.a;
                    }
                    else
                    {
                        this.fromInternal.x = 1f;
                    }
                }

            };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                if (this.uiImage != null)
                {
                    Color c = this.uiImage.color;
                    c.a = val;
                    this.uiImage.color = c;
                }
                else if (this.rawImage != null)
                {
                    Color c = this.rawImage.color;
                    c.a = val;
                    this.rawImage.color = c;
                }
                if (this.useRecursion)
                {
                    alphaRecursive(this.rectTransform, val, 0);
                    textAlphaChildrenRecursive(this.rectTransform, val);
                }
            };
            return this;
        }

        public LTDescr setCanvasGroupAlpha()
        {
            this.type = TweenAction.CANVASGROUP_ALPHA;
            this.initInternal = () => { this.fromInternal.x = trans.GetComponent<CanvasGroup>().alpha; };
            this.easeInternal = () => { this.trans.GetComponent<CanvasGroup>().alpha = easeMethod().x; };
            return this;
        }

        public LTDescr setCanvasColor()
        {
            this.type = TweenAction.CANVAS_COLOR;
            this.initInternal = () =>
            {
                this.uiImage = trans.GetComponent<UnityEngine.UI.Image>();
                if (this.uiImage == null)
                {
                    this.rawImage = trans.GetComponent<UnityEngine.UI.RawImage>();
                    this.setFromColor(this.rawImage != null ? this.rawImage.color : Color.white);
                }
                else
                {
                    this.setFromColor(this.uiImage.color);
                }

            };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                Color toColor = tweenColor(this, val);
                if (this.uiImage != null)
                {
                    this.uiImage.color = toColor;
                }
                else if (this.rawImage != null)
                {
                    this.rawImage.color = toColor;
                }

                if (dt != 0f && this._optional.onUpdateColor != null)
                    this._optional.onUpdateColor(toColor);

                if (this.useRecursion)
                    colorRecursive(this.rectTransform, toColor);
            };
            return this;
        }

        public LTDescr setCanvasMoveX()
        {
            this.type = TweenAction.CANVAS_MOVE_X;
            this.initInternal = () => { this.fromInternal.x = this.rectTransform.anchoredPosition3D.x; };
            this.easeInternal = () =>
            {
                Vector3 c = this.rectTransform.anchoredPosition3D;
                this.rectTransform.anchoredPosition3D = new Vector3(easeMethod().x, c.y, c.z);
            };
            return this;
        }

        public LTDescr setCanvasMoveY()
        {
            this.type = TweenAction.CANVAS_MOVE_Y;
            this.initInternal = () => { this.fromInternal.x = this.rectTransform.anchoredPosition3D.y; };
            this.easeInternal = () =>
            {
                Vector3 c = this.rectTransform.anchoredPosition3D;
                this.rectTransform.anchoredPosition3D = new Vector3(c.x, easeMethod().x, c.z);
            };
            return this;
        }

        public LTDescr setCanvasMoveZ()
        {
            this.type = TweenAction.CANVAS_MOVE_Z;
            this.initInternal = () => { this.fromInternal.x = this.rectTransform.anchoredPosition3D.z; };
            this.easeInternal = () =>
            {
                Vector3 c = this.rectTransform.anchoredPosition3D;
                this.rectTransform.anchoredPosition3D = new Vector3(c.x, c.y, easeMethod().x);
            };
            return this;
        }

        private void initCanvasRotateAround()
        {
            this.lastVal = 0.0f;
            this.fromInternal.x = 0.0f;
            this._optional.origRotation = this.rectTransform.rotation;
        }

        public LTDescr setCanvasRotateAround()
        {
            this.type = TweenAction.CANVAS_ROTATEAROUND;
            this.initInternal = this.initCanvasRotateAround;
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                RectTransform rect = this.rectTransform;
                Vector3 origPos = rect.localPosition;
                rect.RotateAround((Vector3) rect.TransformPoint(this._optional.point), this._optional.axis, -val);
                Vector3 diff = origPos - rect.localPosition;

                rect.localPosition = origPos - diff;
                    // Subtract the amount the object has been shifted over by the rotate, to get it back to it's orginal position
                rect.rotation = this._optional.origRotation;
                rect.RotateAround((Vector3) rect.TransformPoint(this._optional.point), this._optional.axis, val);
            };
            return this;
        }

        public LTDescr setCanvasRotateAroundLocal()
        {
            this.type = TweenAction.CANVAS_ROTATEAROUND_LOCAL;
            this.initInternal = this.initCanvasRotateAround;
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                RectTransform rect = this.rectTransform;
                Vector3 origPos = rect.localPosition;
                rect.RotateAround((Vector3) rect.TransformPoint(this._optional.point),
                    rect.TransformDirection(this._optional.axis), -val);
                Vector3 diff = origPos - rect.localPosition;

                rect.localPosition = origPos - diff;
                    // Subtract the amount the object has been shifted over by the rotate, to get it back to it's orginal position
                rect.rotation = this._optional.origRotation;
                rect.RotateAround((Vector3) rect.TransformPoint(this._optional.point),
                    rect.TransformDirection(this._optional.axis), val);
            };
            return this;
        }

        public LTDescr setCanvasPlaySprite()
        {
            this.type = TweenAction.CANVAS_PLAYSPRITE;
            this.initInternal = () =>
            {
                this.uiImage = trans.GetComponent<UnityEngine.UI.Image>();
                this.fromInternal.x = 0f;
            };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                val = newVect.x;
                int frame = (int) Mathf.Round(val);
                this.uiImage.sprite = this.sprites[frame];
            };
            return this;
        }

        public LTDescr setCanvasMove()
        {
            this.type = TweenAction.CANVAS_MOVE;
            this.initInternal = () => { this.fromInternal = this.rectTransform.anchoredPosition3D; };
            this.easeInternal = () => { this.rectTransform.anchoredPosition3D = easeMethod(); };
            return this;
        }

        public LTDescr setCanvasScale()
        {
            this.type = TweenAction.CANVAS_SCALE;
            this.initInternal = () => { this.from = this.rectTransform.localScale; };
            this.easeInternal = () => { this.rectTransform.localScale = easeMethod(); };
            return this;
        }

        public LTDescr setCanvasSizeDelta()
        {
            this.type = TweenAction.CANVAS_SIZEDELTA;
            this.initInternal = () => { this.from = this.rectTransform.sizeDelta; };
            this.easeInternal = () => { this.rectTransform.sizeDelta = easeMethod(); };
            return this;
        }
#endif

        private void callback()
        {
            newVect = easeMethod();
            val = newVect.x;
        }

        public LTDescr setCallback()
        {
            this.type = TweenAction.CALLBACK;
            this.initInternal = () => { };
            this.easeInternal = this.callback;
            return this;
        }

        public LTDescr setValue3()
        {
            this.type = TweenAction.VALUE3;
            this.initInternal = () => { };
            this.easeInternal = this.callback;
            return this;
        }

        public LTDescr setMove()
        {
            this.type = TweenAction.MOVE;
            this.initInternal = () => { this.from = trans.position; };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                trans.position = newVect;
            };
            return this;
        }

        public LTDescr setMoveLocal()
        {
            this.type = TweenAction.MOVE_LOCAL;
            this.initInternal = () => { this.from = trans.localPosition; };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                trans.localPosition = newVect;
            };
            return this;
        }

        public LTDescr setMoveToTransform()
        {
            this.type = TweenAction.MOVE_TO_TRANSFORM;
            this.initInternal = () => { this.from = trans.position; };
            this.easeInternal = () =>
            {
                this.to = this._optional.toTrans.position;
                this.diff = this.to - this.from;
                this.diffDiv2 = this.diff*0.5f;

                newVect = easeMethod();
                this.trans.position = newVect;
            };
            return this;
        }

        public LTDescr setRotate()
        {
            this.type = TweenAction.ROTATE;
            this.initInternal = () =>
            {
                this.from = trans.eulerAngles;
                this.to = new Vector3(LeanTween.closestRot(this.fromInternal.x, this.toInternal.x),
                    LeanTween.closestRot(this.from.y, this.to.y), LeanTween.closestRot(this.from.z, this.to.z));
            };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                trans.eulerAngles = newVect;
            };
            return this;
        }

        public LTDescr setRotateLocal()
        {
            this.type = TweenAction.ROTATE_LOCAL;
            this.initInternal = () =>
            {
                this.from = trans.localEulerAngles;
                this.to = new Vector3(LeanTween.closestRot(this.fromInternal.x, this.toInternal.x),
                    LeanTween.closestRot(this.from.y, this.to.y), LeanTween.closestRot(this.from.z, this.to.z));
            };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                trans.localEulerAngles = newVect;
            };
            return this;
        }

        public LTDescr setScale()
        {
            this.type = TweenAction.SCALE;
            this.initInternal = () => { this.from = trans.localScale; };
            this.easeInternal = () =>
            {
                newVect = easeMethod();
                trans.localScale = newVect;
            };
            return this;
        }

        public LTDescr setGUIMove()
        {
            this.type = TweenAction.GUI_MOVE;
            this.initInternal =
                () => { this.from = new Vector3(this._optional.ltRect.rect.x, this._optional.ltRect.rect.y, 0); };
            this.easeInternal = () =>
            {
                Vector3 v = easeMethod();
                this._optional.ltRect.rect = new Rect(v.x, v.y, this._optional.ltRect.rect.width,
                    this._optional.ltRect.rect.height);
            };
            return this;
        }

        public LTDescr setGUIMoveMargin()
        {
            this.type = TweenAction.GUI_MOVE_MARGIN;
            this.initInternal =
                () => { this.from = new Vector2(this._optional.ltRect.margin.x, this._optional.ltRect.margin.y); };
            this.easeInternal = () =>
            {
                Vector3 v = easeMethod();
                this._optional.ltRect.margin = new Vector2(v.x, v.y);
            };
            return this;
        }

        public LTDescr setGUIScale()
        {
            this.type = TweenAction.GUI_SCALE;
            this.initInternal =
                () =>
                {
                    this.from = new Vector3(this._optional.ltRect.rect.width, this._optional.ltRect.rect.height, 0);
                };
            this.easeInternal = () =>
            {
                Vector3 v = easeMethod();
                this._optional.ltRect.rect = new Rect(this._optional.ltRect.rect.x, this._optional.ltRect.rect.y, v.x,
                    v.y);
            };
            return this;
        }

        public LTDescr setGUIAlpha()
        {
            this.type = TweenAction.GUI_ALPHA;
            this.initInternal = () => { this.fromInternal.x = this._optional.ltRect.alpha; };
            this.easeInternal = () => { this._optional.ltRect.alpha = easeMethod().x; };
            return this;
        }

        public LTDescr setGUIRotate()
        {
            this.type = TweenAction.GUI_ROTATE;
            this.initInternal = () =>
            {
                if (this._optional.ltRect.rotateEnabled == false)
                {
                    this._optional.ltRect.rotateEnabled = true;
                    this._optional.ltRect.resetForRotation();
                }

                this.fromInternal.x = this._optional.ltRect.rotation;
            };
            this.easeInternal = () => { this._optional.ltRect.rotation = easeMethod().x; };
            return this;
        }

        public LTDescr setDelayedSound()
        {
            this.type = TweenAction.DELAYED_SOUND;
            this.initInternal = () => { this.hasExtraOnCompletes = true; };
            this.easeInternal = this.callback;
            return this;
        }

        private void init()
        {
            this.hasInitiliazed = true;

            usesNormalDt = !(useEstimatedTime || useManualTime || useFrames);
                // only set this to true if it uses non of the other timing modes

            if (useFrames)
                this.optional.initFrameCount = Time.frameCount;

            if (this.time <= 0f) // avoid dividing by zero
                this.time = Mathf.Epsilon;

            this.initInternal();

            this.diff = this.to - this.from;
            this.diffDiv2 = this.diff*0.5f;

            if (this._optional.onStart != null)
                this._optional.onStart();

            if (this.onCompleteOnStart)
                callOnCompletes();

            if (this.speed >= 0)
            {
                initSpeed();
            }
        }

        private void initSpeed()
        {
            if (this.type == TweenAction.MOVE_CURVED || this.type == TweenAction.MOVE_CURVED_LOCAL)
            {
                this.time = this._optional.path.distance/this.speed;
            }
            else if (this.type == TweenAction.MOVE_SPLINE || this.type == TweenAction.MOVE_SPLINE_LOCAL)
            {
                this.time = this._optional.spline.distance/this.speed;
            }
            else
            {
                this.time = (this.to - this.from).magnitude/this.speed;
            }
        }

        public static float val;
        public static float dt;
        public static Vector3 newVect;

        /**
	* If you need a tween to happen immediately instead of waiting for the next Update call, you can force it with this method
	* 
	* @method updateNow
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 0f ).updateNow();
	*/

        public LTDescr updateNow()
        {
            updateInternal();
            return this;
        }

        public bool updateInternal()
        {

            float directionLocal = this.direction;
            if (this.usesNormalDt)
            {
                dt = LeanTween.dtActual;
            }
            else if (this.useEstimatedTime)
            {
                dt = LeanTween.dtEstimated;
            }
            else if (this.useFrames)
            {
                dt = this.optional.initFrameCount == 0 ? 0 : 1;
                this.optional.initFrameCount = Time.frameCount;
            }
            else if (this.useManualTime)
            {
                dt = LeanTween.dtManual;
            }

//		Debug.Log ("tween:" + this+ " dt:"+dt);
            if (this.delay <= 0f && directionLocal != 0f)
            {
                if (trans == null)
                    return true;

                // initialize if has not done so yet
                if (!this.hasInitiliazed)
                    this.init();

                dt = dt*directionLocal;
                this.passed += dt;

                this.passed = Mathf.Clamp(this.passed, 0f, this.time);

                this.ratioPassed = (this.passed/this.time);
                    // need to clamp when finished so it will finish at the exact spot and not overshoot

                this.easeInternal();

                if (this.hasUpdateCallback)
                    this._optional.callOnUpdate(val, this.ratioPassed);

                bool isTweenFinished = directionLocal > 0f ? this.passed >= this.time : this.passed <= 0f;
                //			Debug.Log("lt "+this+" dt:"+dt+" fin:"+isTweenFinished);
                if (isTweenFinished)
                {
                    // increment or flip tween
                    this.loopCount--;
                    if (this.loopType == LeanTweenType.pingPong)
                    {
                        this.direction = 0.0f - directionLocal;
                    }
                    else
                    {
                        this.passed = Mathf.Epsilon;
                    }

                    isTweenFinished = this.loopCount == 0 || this.loopType == LeanTweenType.once;
                        // only return true if it is fully complete

                    if (isTweenFinished == false && this.onCompleteOnRepeat && this.hasExtraOnCompletes)
                        callOnCompletes();
                            // this only gets called if onCompleteOnRepeat is set to true, otherwise LeanTween class takes care of calling it

                    return isTweenFinished;
                }
            }
            else
            {
                this.delay -= dt;
            }

            return false;
        }

        public void callOnCompletes()
        {
            if (this.type == TweenAction.GUI_ROTATE)
                this._optional.ltRect.rotateFinished = true;

            if (this.type == TweenAction.DELAYED_SOUND)
            {
                AudioSource.PlayClipAtPoint((AudioClip) this._optional.onCompleteParam, this.to, this.from.x);
            }
            if (this._optional.onComplete != null)
            {
                this._optional.onComplete();
            }
            else if (this._optional.onCompleteObject != null)
            {
                this._optional.onCompleteObject(this._optional.onCompleteParam);
            }
        }

        // Helper Methods

        public LTDescr setFromColor(Color col)
        {
            this.from = new Vector3(0.0f, col.a, 0.0f);
            this.diff = new Vector3(1.0f, 0.0f, 0.0f);
            this._optional.axis = new Vector3(col.r, col.g, col.b);
            return this;
        }

        private static void alphaRecursive(Transform transform, float val, bool useRecursion = true)
        {
            Renderer renderer = transform.gameObject.GetComponent<Renderer>();
            if (renderer != null)
            {
                foreach (Material mat in renderer.materials)
                {
                    if (mat.HasProperty("_Color"))
                    {
                        mat.color = new Color(mat.color.r, mat.color.g, mat.color.b, val);
                    }
                    else if (mat.HasProperty("_TintColor"))
                    {
                        Color col = mat.GetColor("_TintColor");
                        mat.SetColor("_TintColor", new Color(col.r, col.g, col.b, val));
                    }
                }
            }
            if (useRecursion && transform.childCount > 0)
            {
                foreach (Transform child in transform)
                {
                    alphaRecursive(child, val);
                }
            }
        }

        private static void colorRecursive(Transform transform, Color toColor, bool useRecursion = true)
        {
            Renderer ren = transform.gameObject.GetComponent<Renderer>();
            if (ren != null)
            {
                foreach (Material mat in ren.materials)
                {
                    mat.color = toColor;
                }
            }
            if (useRecursion && transform.childCount > 0)
            {
                foreach (Transform child in transform)
                {
                    colorRecursive(child, toColor);
                }
            }
        }

#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5

        private static void alphaRecursive(RectTransform rectTransform, float val, int recursiveLevel = 0)
        {
            if (rectTransform.childCount > 0)
            {
                foreach (RectTransform child in rectTransform)
                {
                    UnityEngine.UI.MaskableGraphic uiImage = child.GetComponent<UnityEngine.UI.Image>();
                    if (uiImage != null)
                    {
                        Color c = uiImage.color;
                        c.a = val;
                        uiImage.color = c;
                    }
                    else
                    {
                        uiImage = child.GetComponent<UnityEngine.UI.RawImage>();
                        if (uiImage != null)
                        {
                            Color c = uiImage.color;
                            c.a = val;
                            uiImage.color = c;
                        }
                    }

                    alphaRecursive(child, val, recursiveLevel + 1);
                }
            }
        }

        private static void alphaRecursiveSprite(Transform transform, float val)
        {
            if (transform.childCount > 0)
            {
                foreach (Transform child in transform)
                {
                    SpriteRenderer ren = child.GetComponent<SpriteRenderer>();
                    if (ren != null)
                        ren.color = new Color(ren.color.r, ren.color.g, ren.color.b, val);
                    alphaRecursiveSprite(child, val);
                }
            }
        }

        private static void colorRecursiveSprite(Transform transform, Color toColor)
        {
            if (transform.childCount > 0)
            {
                foreach (Transform child in transform)
                {
                    SpriteRenderer ren = transform.gameObject.GetComponent<SpriteRenderer>();
                    if (ren != null)
                        ren.color = toColor;
                    colorRecursiveSprite(child, toColor);
                }
            }
        }

        private static void colorRecursive(RectTransform rectTransform, Color toColor)
        {

            if (rectTransform.childCount > 0)
            {
                foreach (RectTransform child in rectTransform)
                {
                    UnityEngine.UI.MaskableGraphic uiImage = child.GetComponent<UnityEngine.UI.Image>();
                    if (uiImage != null)
                    {
                        uiImage.color = toColor;
                    }
                    else
                    {
                        uiImage = child.GetComponent<UnityEngine.UI.RawImage>();
                        if (uiImage != null)
                            uiImage.color = toColor;
                    }
                    colorRecursive(child, toColor);
                }
            }
        }

        private static void textAlphaChildrenRecursive(Transform trans, float val, bool useRecursion = true)
        {

            if (useRecursion && trans.childCount > 0)
            {
                foreach (Transform child in trans)
                {
                    UnityEngine.UI.Text uiText = child.GetComponent<UnityEngine.UI.Text>();
                    if (uiText != null)
                    {
                        Color c = uiText.color;
                        c.a = val;
                        uiText.color = c;
                    }
                    textAlphaChildrenRecursive(child, val);
                }
            }
        }

        private static void textAlphaRecursive(Transform trans, float val, bool useRecursion = true)
        {
            UnityEngine.UI.Text uiText = trans.GetComponent<UnityEngine.UI.Text>();
            if (uiText != null)
            {
                Color c = uiText.color;
                c.a = val;
                uiText.color = c;
            }
            if (useRecursion && trans.childCount > 0)
            {
                foreach (Transform child in trans)
                {
                    textAlphaRecursive(child, val);
                }
            }
        }

        private static void textColorRecursive(Transform trans, Color toColor)
        {
            if (trans.childCount > 0)
            {
                foreach (Transform child in trans)
                {
                    UnityEngine.UI.Text uiText = child.GetComponent<UnityEngine.UI.Text>();
                    if (uiText != null)
                    {
                        uiText.color = toColor;
                    }
                    textColorRecursive(child, toColor);
                }
            }
        }
#endif

        private static Color tweenColor(LTDescr tween, float val)
        {
            Vector3 diff3 = tween._optional.point - tween._optional.axis;
            float diffAlpha = tween.to.y - tween.from.y;
            return new Color(tween._optional.axis.x + diff3.x*val, tween._optional.axis.y + diff3.y*val,
                tween._optional.axis.z + diff3.z*val, tween.from.y + diffAlpha*val);
        }

        /**
	* Pause a tween
	* 
	* @method pause
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	*/

        public LTDescr pause()
        {
            if (this.direction != 0.0f)
            {
                // check if tween is already paused
                this.directionLast = this.direction;
                this.direction = 0.0f;
            }

            return this;
        }

        /**
	* Resume a paused tween
	* 
	* @method resume
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	*/

        public LTDescr resume()
        {
            this.direction = this.directionLast;

            return this;
        }

        /**
	* Set Axis optional axis for tweens where it is relevant
	* 
	* @method setAxis
	* @param {Vector3} axis either the tween rotates around, or the direction it faces in the case of setOrientToPath
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.move( ltLogo, path, 1.0f ).setEase(LeanTweenType.easeOutQuad).setOrientToPath(true).setAxis(Vector3.forward);
	*/

        public LTDescr setAxis(Vector3 axis)
        {
            this._optional.axis = axis;
            return this;
        }

        /**
	* Delay the start of a tween
	* 
	* @method setDelay
	* @param {float} float time The time to complete the tween in
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setDelay( 1.5f );
	*/

        public LTDescr setDelay(float delay)
        {
            this.delay = delay;

            return this;
        }

        /**
	* Set the type of easing used for the tween. <br>
	* <ul><li><a href="LeanTweenType.html">List of all the ease types</a>.</li>
	* <li><a href="http://www.robertpenner.com/easing/easing_demo.html">This page helps visualize the different easing equations</a></li>
	* </ul>
	* 
	* @method setEase
	* @param {LeanTweenType} easeType:LeanTweenType the easing type to use
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setEase( LeanTweenType.easeInBounce );
	*/

        public LTDescr setEase(LeanTweenType easeType)
        {

            switch (easeType)
            {
                case LeanTweenType.linear:
                    setEaseLinear();
                    break;
                case LeanTweenType.easeOutQuad:
                    setEaseOutQuad();
                    break;
                case LeanTweenType.easeInQuad:
                    setEaseInQuad();
                    break;
                case LeanTweenType.easeInOutQuad:
                    setEaseInOutQuad();
                    break;
                case LeanTweenType.easeInCubic:
                    setEaseInCubic();
                    break;
                case LeanTweenType.easeOutCubic:
                    setEaseOutCubic();
                    break;
                case LeanTweenType.easeInOutCubic:
                    setEaseInOutCubic();
                    break;
                case LeanTweenType.easeInQuart:
                    setEaseInQuart();
                    break;
                case LeanTweenType.easeOutQuart:
                    setEaseOutQuart();
                    break;
                case LeanTweenType.easeInOutQuart:
                    setEaseInOutQuart();
                    break;
                case LeanTweenType.easeInQuint:
                    setEaseInQuint();
                    break;
                case LeanTweenType.easeOutQuint:
                    setEaseOutQuint();
                    break;
                case LeanTweenType.easeInOutQuint:
                    setEaseInOutQuint();
                    break;
                case LeanTweenType.easeInSine:
                    setEaseInSine();
                    break;
                case LeanTweenType.easeOutSine:
                    setEaseOutSine();
                    break;
                case LeanTweenType.easeInOutSine:
                    setEaseInOutSine();
                    break;
                case LeanTweenType.easeInExpo:
                    setEaseInExpo();
                    break;
                case LeanTweenType.easeOutExpo:
                    setEaseOutExpo();
                    break;
                case LeanTweenType.easeInOutExpo:
                    setEaseInOutExpo();
                    break;
                case LeanTweenType.easeInCirc:
                    setEaseInCirc();
                    break;
                case LeanTweenType.easeOutCirc:
                    setEaseOutCirc();
                    break;
                case LeanTweenType.easeInOutCirc:
                    setEaseInOutCirc();
                    break;
                case LeanTweenType.easeInBounce:
                    setEaseInBounce();
                    break;
                case LeanTweenType.easeOutBounce:
                    setEaseOutBounce();
                    break;
                case LeanTweenType.easeInOutBounce:
                    setEaseInOutBounce();
                    break;
                case LeanTweenType.easeInBack:
                    setEaseInBack();
                    break;
                case LeanTweenType.easeOutBack:
                    setEaseOutBack();
                    break;
                case LeanTweenType.easeInOutBack:
                    setEaseInOutBack();
                    break;
                case LeanTweenType.easeInElastic:
                    setEaseInElastic();
                    break;
                case LeanTweenType.easeOutElastic:
                    setEaseOutElastic();
                    break;
                case LeanTweenType.easeInOutElastic:
                    setEaseInOutElastic();
                    break;
                case LeanTweenType.punch:
                    setEasePunch();
                    break;
                case LeanTweenType.easeShake:
                    setEaseShake();
                    break;
                case LeanTweenType.easeSpring:
                    setEaseSpring();
                    break;
                default:
                    setEaseLinear();
                    break;
            }

            return this;
        }

        public LTDescr setEaseLinear()
        {
            this.easeType = LeanTweenType.linear;
            this.easeMethod = this.easeLinear;
            return this;
        }

        public LTDescr setEaseSpring()
        {
            this.easeType = LeanTweenType.easeSpring;
            this.easeMethod = this.easeSpring;
            return this;
        }

        public LTDescr setEaseInQuad()
        {
            this.easeType = LeanTweenType.easeInQuad;
            this.easeMethod = this.easeInQuad;
            return this;
        }

        public LTDescr setEaseOutQuad()
        {
            this.easeType = LeanTweenType.easeOutQuad;
            this.easeMethod = this.easeOutQuad;
            return this;
        }

        public LTDescr setEaseInOutQuad()
        {
            this.easeType = LeanTweenType.easeInOutQuad;
            this.easeMethod = this.easeInOutQuad;
            return this;
        }

        public LTDescr setEaseInCubic()
        {
            this.easeType = LeanTweenType.easeInCubic;
            this.easeMethod = this.easeInCubic;
            return this;
        }

        public LTDescr setEaseOutCubic()
        {
            this.easeType = LeanTweenType.easeOutCubic;
            this.easeMethod = this.easeOutCubic;
            return this;
        }

        public LTDescr setEaseInOutCubic()
        {
            this.easeType = LeanTweenType.easeInOutCubic;
            this.easeMethod = this.easeInOutCubic;
            return this;
        }

        public LTDescr setEaseInQuart()
        {
            this.easeType = LeanTweenType.easeInQuart;
            this.easeMethod = this.easeInQuart;
            return this;
        }

        public LTDescr setEaseOutQuart()
        {
            this.easeType = LeanTweenType.easeOutQuart;
            this.easeMethod = this.easeOutQuart;
            return this;
        }

        public LTDescr setEaseInOutQuart()
        {
            this.easeType = LeanTweenType.easeInOutQuart;
            this.easeMethod = this.easeInOutQuart;
            return this;
        }

        public LTDescr setEaseInQuint()
        {
            this.easeType = LeanTweenType.easeInQuint;
            this.easeMethod = this.easeInQuint;
            return this;
        }

        public LTDescr setEaseOutQuint()
        {
            this.easeType = LeanTweenType.easeOutQuint;
            this.easeMethod = this.easeOutQuint;
            return this;
        }

        public LTDescr setEaseInOutQuint()
        {
            this.easeType = LeanTweenType.easeInOutQuint;
            this.easeMethod = this.easeInOutQuint;
            return this;
        }

        public LTDescr setEaseInSine()
        {
            this.easeType = LeanTweenType.easeInSine;
            this.easeMethod = this.easeInSine;
            return this;
        }

        public LTDescr setEaseOutSine()
        {
            this.easeType = LeanTweenType.easeOutSine;
            this.easeMethod = this.easeOutSine;
            return this;
        }

        public LTDescr setEaseInOutSine()
        {
            this.easeType = LeanTweenType.easeInOutSine;
            this.easeMethod = this.easeInOutSine;
            return this;
        }

        public LTDescr setEaseInExpo()
        {
            this.easeType = LeanTweenType.easeInExpo;
            this.easeMethod = this.easeInExpo;
            return this;
        }

        public LTDescr setEaseOutExpo()
        {
            this.easeType = LeanTweenType.easeOutExpo;
            this.easeMethod = this.easeOutExpo;
            return this;
        }

        public LTDescr setEaseInOutExpo()
        {
            this.easeType = LeanTweenType.easeInOutExpo;
            this.easeMethod = this.easeInOutExpo;
            return this;
        }

        public LTDescr setEaseInCirc()
        {
            this.easeType = LeanTweenType.easeInCirc;
            this.easeMethod = this.easeInCirc;
            return this;
        }

        public LTDescr setEaseOutCirc()
        {
            this.easeType = LeanTweenType.easeOutCirc;
            this.easeMethod = this.easeOutCirc;
            return this;
        }

        public LTDescr setEaseInOutCirc()
        {
            this.easeType = LeanTweenType.easeInOutCirc;
            this.easeMethod = this.easeInOutCirc;
            return this;
        }

        public LTDescr setEaseInBounce()
        {
            this.easeType = LeanTweenType.easeInBounce;
            this.easeMethod = this.easeInBounce;
            return this;
        }

        public LTDescr setEaseOutBounce()
        {
            this.easeType = LeanTweenType.easeOutBounce;
            this.easeMethod = this.easeOutBounce;
            return this;
        }

        public LTDescr setEaseInOutBounce()
        {
            this.easeType = LeanTweenType.easeInOutBounce;
            this.easeMethod = this.easeInOutBounce;
            return this;
        }

        public LTDescr setEaseInBack()
        {
            this.easeType = LeanTweenType.easeInBack;
            this.easeMethod = this.easeInBack;
            return this;
        }

        public LTDescr setEaseOutBack()
        {
            this.easeType = LeanTweenType.easeOutBack;
            this.easeMethod = this.easeOutBack;
            return this;
        }

        public LTDescr setEaseInOutBack()
        {
            this.easeType = LeanTweenType.easeInOutBack;
            this.easeMethod = this.easeInOutBack;
            return this;
        }

        public LTDescr setEaseInElastic()
        {
            this.easeType = LeanTweenType.easeInElastic;
            this.easeMethod = this.easeInElastic;
            return this;
        }

        public LTDescr setEaseOutElastic()
        {
            this.easeType = LeanTweenType.easeOutElastic;
            this.easeMethod = this.easeOutElastic;
            return this;
        }

        public LTDescr setEaseInOutElastic()
        {
            this.easeType = LeanTweenType.easeInOutElastic;
            this.easeMethod = this.easeInOutElastic;
            return this;
        }

        public LTDescr setEasePunch()
        {
            this._optional.animationCurve = LeanTween.punch;
            this.toInternal.x = this.from.x + this.to.x;
            this.easeMethod = this.tweenOnCurve;
            return this;
        }

        public LTDescr setEaseShake()
        {
            this._optional.animationCurve = LeanTween.shake;
            this.toInternal.x = this.from.x + this.to.x;
            this.easeMethod = this.tweenOnCurve;
            return this;
        }

        private Vector3 tweenOnCurve()
        {
            return new Vector3(this.from.x + (this.diff.x)*this._optional.animationCurve.Evaluate(ratioPassed),
                this.from.y + (this.diff.y)*this._optional.animationCurve.Evaluate(ratioPassed),
                this.from.z + (this.diff.z)*this._optional.animationCurve.Evaluate(ratioPassed));
        }

        // Vector3 Ease Methods

        private Vector3 easeInOutQuad()
        {
            val = this.ratioPassed*2f;

            if (val < 1f)
            {
                val = val*val;
                return new Vector3(this.diffDiv2.x*val + this.from.x, this.diffDiv2.y*val + this.from.y,
                    this.diffDiv2.z*val + this.from.z);
            }
            val = (1f - val)*(val - 3f) + 1f;
            return new Vector3(this.diffDiv2.x*val + this.from.x, this.diffDiv2.y*val + this.from.y,
                this.diffDiv2.z*val + this.from.z);
        }

        private Vector3 easeInQuad()
        {
            val = ratioPassed*ratioPassed;
            return new Vector3(this.diff.x*val + this.from.x, this.diff.y*val + this.from.y,
                this.diff.z*val + this.from.z);
        }

        private Vector3 easeOutQuad()
        {
            val = this.ratioPassed;
            val = -val*(val - 2f);
            return (this.diff*val + this.from);
        }

        private Vector3 easeLinear()
        {
            val = this.ratioPassed;
            return new Vector3(this.from.x + this.diff.x*val, this.from.y + this.diff.y*val,
                this.from.z + this.diff.z*val);
        }

        private Vector3 easeSpring()
        {
            val = Mathf.Clamp01(this.ratioPassed);
            val = (Mathf.Sin(val*Mathf.PI*(0.2f + 2.5f*val*val*val))*Mathf.Pow(1f - val, 2.2f) + val)*
                  (1f + (1.2f*(1f - val)));
            return this.from + this.diff*val;
        }

        private Vector3 easeInCubic()
        {
            val = this.ratioPassed*this.ratioPassed*this.ratioPassed;
            return new Vector3(this.diff.x*val + this.from.x, this.diff.y*val + this.from.y,
                this.diff.z*val + this.from.z);
        }

        private Vector3 easeOutCubic()
        {
            val = this.ratioPassed - 1f;
            val = (val*val*val + 1);
            return new Vector3(this.diff.x*val + this.from.x, this.diff.y*val + this.from.y,
                this.diff.z*val + this.from.z);
        }

        private Vector3 easeInOutCubic()
        {
            val = this.ratioPassed*2f;
            if (val < 1f)
            {
                val = val*val*val;
                return new Vector3(this.diffDiv2.x*val + this.from.x, this.diffDiv2.y*val + this.from.y,
                    this.diffDiv2.z*val + this.from.z);
            }
            val -= 2f;
            val = val*val*val + 2f;
            return new Vector3(this.diffDiv2.x*val + this.from.x, this.diffDiv2.y*val + this.from.y,
                this.diffDiv2.z*val + this.from.z);
        }

        private Vector3 easeInQuart()
        {
            val = this.ratioPassed*this.ratioPassed*this.ratioPassed*this.ratioPassed;
            return diff*val + this.from;
        }

        private Vector3 easeOutQuart()
        {
            val = this.ratioPassed - 1f;
            val = -(val*val*val*val - 1);
            return new Vector3(this.diff.x*val + this.from.x, this.diff.y*val + this.from.y,
                this.diff.z*val + this.from.z);
        }

        private Vector3 easeInOutQuart()
        {
            val = this.ratioPassed*2f;
            if (val < 1f)
            {
                val = val*val*val*val;
                return new Vector3(this.diffDiv2.x*val + this.from.x, this.diffDiv2.y*val + this.from.y,
                    this.diffDiv2.z*val + this.from.z);
            }
            val -= 2f;
//		val = (val * val * val * val - 2f);
            return -this.diffDiv2*(val*val*val*val - 2f) + this.from;
        }

        private Vector3 easeInQuint()
        {
            val = this.ratioPassed;
            val = val*val*val*val*val;
            return new Vector3(this.diff.x*val + this.from.x, this.diff.y*val + this.from.y,
                this.diff.z*val + this.from.z);
        }

        private Vector3 easeOutQuint()
        {
            val = this.ratioPassed - 1f;
            val = (val*val*val*val*val + 1f);
            return new Vector3(this.diff.x*val + this.from.x, this.diff.y*val + this.from.y,
                this.diff.z*val + this.from.z);
        }

        private Vector3 easeInOutQuint()
        {
            val = this.ratioPassed*2f;
            if (val < 1f)
            {
                val = val*val*val*val*val;
                return new Vector3(this.diffDiv2.x*val + this.from.x, this.diffDiv2.y*val + this.from.y,
                    this.diffDiv2.z*val + this.from.z);
            }
            val -= 2f;
            val = (val*val*val*val*val + 2f);
            return new Vector3(this.diffDiv2.x*val + this.from.x, this.diffDiv2.y*val + this.from.y,
                this.diffDiv2.z*val + this.from.z);
        }

        private Vector3 easeInSine()
        {
            val = - Mathf.Cos(this.ratioPassed*LeanTween.PI_DIV2);
            return new Vector3(this.diff.x*val + this.diff.x + this.from.x, this.diff.y*val + this.diff.y + this.from.y,
                this.diff.z*val + this.diff.z + this.from.z);
        }

        private Vector3 easeOutSine()
        {
            val = Mathf.Sin(this.ratioPassed*LeanTween.PI_DIV2);
            return new Vector3(this.diff.x*val + this.from.x, this.diff.y*val + this.from.y,
                this.diff.z*val + this.from.z);
        }

        private Vector3 easeInOutSine()
        {
            val = -(Mathf.Cos(Mathf.PI*this.ratioPassed) - 1f);
            return new Vector3(this.diffDiv2.x*val + this.from.x, this.diffDiv2.y*val + this.from.y,
                this.diffDiv2.z*val + this.from.z);
        }

        private Vector3 easeInExpo()
        {
            val = Mathf.Pow(2f, 10f*(this.ratioPassed - 1f));
            return new Vector3(this.diff.x*val + this.from.x, this.diff.y*val + this.from.y,
                this.diff.z*val + this.from.z);
        }

        private Vector3 easeOutExpo()
        {
            val = (-Mathf.Pow(2f, -10f*this.ratioPassed) + 1f);
            return new Vector3(this.diff.x*val + this.from.x, this.diff.y*val + this.from.y,
                this.diff.z*val + this.from.z);
        }

        private Vector3 easeInOutExpo()
        {
            val = this.ratioPassed*2f;
            if (val < 1) return this.diffDiv2*Mathf.Pow(2, 10*(val - 1)) + this.from;
            val--;
            return this.diffDiv2*(-Mathf.Pow(2, -10*val) + 2) + this.from;
        }

        private Vector3 easeInCirc()
        {
            val = -(Mathf.Sqrt(1f - this.ratioPassed*this.ratioPassed) - 1f);
            return new Vector3(this.diff.x*val + this.from.x, this.diff.y*val + this.from.y,
                this.diff.z*val + this.from.z);
        }

        private Vector3 easeOutCirc()
        {
            val = this.ratioPassed - 1f;
            val = Mathf.Sqrt(1f - val*val);

            return new Vector3(this.diff.x*val + this.from.x, this.diff.y*val + this.from.y,
                this.diff.z*val + this.from.z);
        }

        private Vector3 easeInOutCirc()
        {
            val = this.ratioPassed*2f;
            if (val < 1f)
            {
                val = -(Mathf.Sqrt(1f - val*val) - 1f);
                return new Vector3(this.diffDiv2.x*val + this.from.x, this.diffDiv2.y*val + this.from.y,
                    this.diffDiv2.z*val + this.from.z);
            }
            val -= 2f;
            val = (Mathf.Sqrt(1f - val*val) + 1f);
            return new Vector3(this.diffDiv2.x*val + this.from.x, this.diffDiv2.y*val + this.from.y,
                this.diffDiv2.z*val + this.from.z);
        }

        private Vector3 easeInBounce()
        {
            val = this.ratioPassed;
            val = 1f - val;
            return new Vector3(this.diff.x - LeanTween.easeOutBounce(0, this.diff.x, val) + this.from.x,
                this.diff.y - LeanTween.easeOutBounce(0, this.diff.y, val) + this.from.y,
                this.diff.z - LeanTween.easeOutBounce(0, this.diff.z, val) + this.from.z);
        }

        private Vector3 easeOutBounce()
        {
            val = ratioPassed;
            float valM, valN; // bounce values
            if (val < (valM = 1 - 1.75f*this.overshoot/2.75f))
            {
                val = 1/valM/valM*val*val;
            }
            else if (val < (valN = 1 - .75f*this.overshoot/2.75f))
            {
                val -= (valM + valN)/2;
                // first bounce, height: 1/4
                val = 7.5625f*val*val + 1 - .25f*this.overshoot*this.overshoot;
            }
            else if (val < (valM = 1 - .25f*this.overshoot/2.75f))
            {
                val -= (valM + valN)/2;
                // second bounce, height: 1/16
                val = 7.5625f*val*val + 1 - .0625f*this.overshoot*this.overshoot;
            }
            else
            {
                // valN = 1
                val -= (valM + 1)/2;
                // third bounce, height: 1/64
                val = 7.5625f*val*val + 1 - .015625f*this.overshoot*this.overshoot;
            }
            return this.diff*val + this.from;
        }

        private Vector3 easeInOutBounce()
        {
            val = this.ratioPassed*2f;
            if (val < 1f)
            {
                return new Vector3(LeanTween.easeInBounce(0, this.diff.x, val)*0.5f + this.from.x,
                    LeanTween.easeInBounce(0, this.diff.y, val)*0.5f + this.from.y,
                    LeanTween.easeInBounce(0, this.diff.z, val)*0.5f + this.from.z);
            }
            else
            {
                val = val - 1f;
                return new Vector3(LeanTween.easeOutBounce(0, this.diff.x, val)*0.5f + this.diffDiv2.x + this.from.x,
                    LeanTween.easeOutBounce(0, this.diff.y, val)*0.5f + this.diffDiv2.y + this.from.y,
                    LeanTween.easeOutBounce(0, this.diff.z, val)*0.5f + this.diffDiv2.z + this.from.z);
            }
        }

        private Vector3 easeInBack()
        {
            val = this.ratioPassed;
            val /= 1;
            float s = 1.70158f*this.overshoot;
            return this.diff*(val)*val*((s + 1)*val - s) + this.from;
        }

        private Vector3 easeOutBack()
        {
            float s = 1.70158f*this.overshoot;
            val = (this.ratioPassed/1) - 1;
            val = ((val)*val*((s + 1)*val + s) + 1);
            return this.diff*val + this.from;
        }

        private Vector3 easeInOutBack()
        {
            float s = 1.70158f*this.overshoot;
            val = this.ratioPassed*2f;
            if ((val) < 1)
            {
                s *= (1.525f)*overshoot;
                return this.diffDiv2*(val*val*(((s) + 1)*val - s)) + this.from;
            }
            val -= 2;
            s *= (1.525f)*overshoot;
            val = ((val)*val*(((s) + 1)*val + s) + 2);
            return this.diffDiv2*val + this.from;
        }

        private Vector3 easeInElastic()
        {
            return
                new Vector3(
                    LeanTween.easeInElastic(this.from.x, this.to.x, this.ratioPassed, this.overshoot, this.period),
                    LeanTween.easeInElastic(this.from.y, this.to.y, this.ratioPassed, this.overshoot, this.period),
                    LeanTween.easeInElastic(this.from.z, this.to.z, this.ratioPassed, this.overshoot, this.period));
        }

        private Vector3 easeOutElastic()
        {
            return
                new Vector3(
                    LeanTween.easeOutElastic(this.from.x, this.to.x, this.ratioPassed, this.overshoot, this.period),
                    LeanTween.easeOutElastic(this.from.y, this.to.y, this.ratioPassed, this.overshoot, this.period),
                    LeanTween.easeOutElastic(this.from.z, this.to.z, this.ratioPassed, this.overshoot, this.period));
        }

        private Vector3 easeInOutElastic()
        {
            return
                new Vector3(
                    LeanTween.easeInOutElastic(this.from.x, this.to.x, this.ratioPassed, this.overshoot, this.period),
                    LeanTween.easeInOutElastic(this.from.y, this.to.y, this.ratioPassed, this.overshoot, this.period),
                    LeanTween.easeInOutElastic(this.from.z, this.to.z, this.ratioPassed, this.overshoot, this.period));
        }

        /**
	* Set how far past a tween will overshoot  for certain ease types (compatible:  easeInBack, easeInOutBack, easeOutBack, easeOutElastic, easeInElastic, easeInOutElastic). <br>
	* @method setOvershoot
	* @param {float} overshoot:float how far past the destination it will go before settling in
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setEase( LeanTweenType.easeOutBack ).setOvershoot(2f);
	*/

        public LTDescr setOvershoot(float overshoot)
        {
            this.overshoot = overshoot;
            return this;
        }

        /**
	* Set how short the iterations are for certain ease types (compatible: easeOutElastic, easeInElastic, easeInOutElastic). <br>
	* @method setPeriod
	* @param {float} period:float how short the iterations are that the tween will animate at (default 0.3f)
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setEase( LeanTweenType.easeOutElastic ).setPeriod(0.3f);
	*/

        public LTDescr setPeriod(float period)
        {
            this.period = period;
            return this;
        }

        /**
    * Set how large the effect is for certain ease types (compatible: punch, shake, animation curves). <br>
    * @method setScale
    * @param {float} scale:float how much the ease will be multiplied by (default 1f)
    * @return {LTDescr} LTDescr an object that distinguishes the tween
    * @example
    * LeanTween.moveX(gameObject, 5f, 2.0f ).setEase( LeanTweenType.punch ).setScale(2f);
    */

        public LTDescr setScale(float scale)
        {
            this.scale = scale;
            return this;
        }

        /**
	* Set the type of easing used for the tween with a custom curve. <br>
	* @method setEase (AnimationCurve)
	* @param {AnimationCurve} easeDefinition:AnimationCurve an <a href="http://docs.unity3d.com/Documentation/ScriptReference/AnimationCurve.html" target="_blank">AnimationCure</a> that describes the type of easing you want, this is great for when you want a unique type of movement
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setEase( LeanTweenType.easeInBounce );
	*/

        public LTDescr setEase(AnimationCurve easeCurve)
        {
            this._optional.animationCurve = easeCurve;
            this.easeMethod = this.tweenOnCurve;
            this.easeType = LeanTweenType.animationCurve;
            return this;
        }

        /**
	* Set the end that the GameObject is tweening towards
	* @method setTo
	* @param {Vector3} to:Vector3 point at which you want the tween to reach
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LTDescr descr = LeanTween.move( cube, Vector3.up, new Vector3(1f,3f,0f), 1.0f ).setEase( LeanTweenType.easeInOutBounce );<br>
	* // Later your want to change your destination or your destiation is constantly moving<br>
	* descr.setTo( new Vector3(5f,10f,3f) );<br>
	*/

        public LTDescr setTo(Vector3 to)
        {
            if (this.hasInitiliazed)
            {
                this.to = to;
                this.diff = to - this.from;
            }
            else
            {
                this.to = to;
            }

            return this;
        }

        public LTDescr setTo(Transform to)
        {
            this._optional.toTrans = to;
            return this;
        }

        /**
	* Set the beginning of the tween
	* @method setFrom
	* @param {Vector3} from:Vector3 the point you would like the tween to start at
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LTDescr descr = LeanTween.move( cube, Vector3.up, new Vector3(1f,3f,0f), 1.0f ).setFrom( new Vector3(5f,10f,3f) );<br>
	*/

        public LTDescr setFrom(Vector3 from)
        {
            if (this.trans)
            {
                this.init();
            }
            this.from = from;
            // this.hasInitiliazed = true; // this is set, so that the "from" value isn't overwritten later on when the tween starts
            this.diff = this.to - this.from;
            this.diffDiv2 = this.diff*0.5f;
            return this;
        }

        public LTDescr setFrom(float from)
        {
            return setFrom(new Vector3(from, 0f, 0f));
        }

        public LTDescr setDiff(Vector3 diff)
        {
            this.diff = diff;
            return this;
        }

        public LTDescr setHasInitialized(bool has)
        {
            this.hasInitiliazed = has;
            return this;
        }

        public LTDescr setId(uint id, uint global_counter)
        {
            this._id = id;
            this.counter = global_counter;
            // Debug.Log("Global counter:"+global_counter);
            return this;
        }

        /**
	* Set the point of time the tween will start in
	* @method setPassed
	* @param {float} passedTime:float the length of time in seconds the tween will start in
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* int tweenId = LeanTween.moveX(gameObject, 5f, 2.0f ).id;<br>
	* // Later<br>
	* LTDescr descr = description( tweenId );<br>
	* descr.setPassed( 1f );<br>
	*/

        public LTDescr setPassed(float passed)
        {
            this.passed = passed;
            return this;
        }

        /**
	* Set the finish time of the tween
	* @method setTime
	* @param {float} finishTime:float the length of time in seconds you wish the tween to complete in
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* int tweenId = LeanTween.moveX(gameObject, 5f, 2.0f ).id;<br>
	* // Later<br>
	* LTDescr descr = description( tweenId );<br>
	* descr.setTime( 1f );<br>
	*/

        public LTDescr setTime(float time)
        {
            float passedTimeRatio = this.passed/this.time;
            this.passed = time*passedTimeRatio;
            this.time = time;
            return this;
        }

        /**
	* Set the finish time of the tween
	* @method setSpeed
	* @param {float} speed:float the speed in unity units per second you wish the object to travel (overrides the given time)
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveLocalZ( gameObject, 10f, 1f).setSpeed(0.2f) // the given time is ignored when speed is set<br>
	*/

        public LTDescr setSpeed(float speed)
        {
            this.speed = speed;
            if (this.hasInitiliazed)
                initSpeed();
            return this;
        }

        /**
	* Set the tween to repeat a number of times.
	* @method setRepeat
	* @param {int} repeatNum:int the number of times to repeat the tween. -1 to repeat infinite times
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setRepeat( 10 ).setLoopPingPong();
	*/

        public LTDescr setRepeat(int repeat)
        {
            this.loopCount = repeat;
            if ((repeat > 1 && this.loopType == LeanTweenType.once) ||
                (repeat < 0 && this.loopType == LeanTweenType.once))
            {
                this.loopType = LeanTweenType.clamp;
            }
            if (this.type == TweenAction.CALLBACK || this.type == TweenAction.CALLBACK_COLOR)
            {
                this.setOnCompleteOnRepeat(true);
            }
            return this;
        }

        public LTDescr setLoopType(LeanTweenType loopType)
        {
            this.loopType = loopType;
            return this;
        }

        public LTDescr setUseEstimatedTime(bool useEstimatedTime)
        {
            this.useEstimatedTime = useEstimatedTime;
            this.usesNormalDt = false;
            return this;
        }

        /**
	* Set ignore time scale when tweening an object when you want the animation to be time-scale independent (ignores the Time.timeScale value). Great for pause screens, when you want all other action to be stopped (or slowed down)
	* @method setIgnoreTimeScale
	* @param {bool} useUnScaledTime:bool whether to use the unscaled time or not
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setRepeat( 2 ).setIgnoreTimeScale( true );
	*/

        public LTDescr setIgnoreTimeScale(bool useUnScaledTime)
        {
            this.useEstimatedTime = useUnScaledTime;
            this.usesNormalDt = false;
            return this;
        }

        /**
	* Use frames when tweening an object, when you don't want the animation to be time-frame independent...
	* @method setUseFrames
	* @param {bool} useFrames:bool whether to use estimated time or not
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setRepeat( 2 ).setUseFrames( true );
	*/

        public LTDescr setUseFrames(bool useFrames)
        {
            this.useFrames = useFrames;
            this.usesNormalDt = false;
            return this;
        }

        public LTDescr setUseManualTime(bool useManualTime)
        {
            this.useManualTime = useManualTime;
            this.usesNormalDt = false;
            return this;
        }

        public LTDescr setLoopCount(int loopCount)
        {
            this.loopType = LeanTweenType.clamp;
            this.loopCount = loopCount;
            return this;
        }

        /**
	* No looping involved, just run once (the default)
	* @method setLoopOnce
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setLoopOnce();
	*/

        public LTDescr setLoopOnce()
        {
            this.loopType = LeanTweenType.once;
            return this;
        }

        /**
	* When the animation gets to the end it starts back at where it began
	* @method setLoopClamp
	* @param {int} loops:int (defaults to -1) how many times you want the loop to happen (-1 for an infinite number of times)
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setLoopClamp( 2 );
	*/

        public LTDescr setLoopClamp()
        {
            this.loopType = LeanTweenType.clamp;
            if (this.loopCount == 0)
                this.loopCount = -1;
            return this;
        }

        public LTDescr setLoopClamp(int loops)
        {
            this.loopCount = loops;
            return this;
        }

        /**
	* When the animation gets to the end it then tweens back to where it started (and on, and on)
	* @method setLoopPingPong
	* @param {int} loops:int (defaults to -1) how many times you want the loop to happen in both directions (-1 for an infinite number of times). Passing a value of 1 will cause the object to go towards and back from it's destination once.
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setLoopPingPong( 2 );
	*/

        public LTDescr setLoopPingPong()
        {
            this.loopType = LeanTweenType.pingPong;
            if (this.loopCount == 0)
                this.loopCount = -1;
            return this;
        }

        public LTDescr setLoopPingPong(int loops)
        {
            this.loopType = LeanTweenType.pingPong;
            this.loopCount = loops == -1 ? loops : loops*2;
            return this;
        }

        /**
	* Have a method called when the tween finishes
	* @method setOnComplete
	* @param {Action} onComplete:Action the method that should be called when the tween is finished ex: tweenFinished(){ }
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnComplete( tweenFinished );
	*/

        public LTDescr setOnComplete(Action onComplete)
        {
            this._optional.onComplete = onComplete;
            this.hasExtraOnCompletes = true;
            return this;
        }

        /**
	* Have a method called when the tween finishes
	* @method setOnComplete (object)
	* @param {Action<object>} onComplete:Action<object> the method that should be called when the tween is finished ex: tweenFinished( object myObj ){ }
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* object tweenFinishedObj = "hi" as object;
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnComplete( tweenFinished, tweenFinishedObj );
	*/

        public LTDescr setOnComplete(Action<object> onComplete)
        {
            this._optional.onCompleteObject = onComplete;
            this.hasExtraOnCompletes = true;
            return this;
        }

        public LTDescr setOnComplete(Action<object> onComplete, object onCompleteParam)
        {
            this._optional.onCompleteObject = onComplete;
            this.hasExtraOnCompletes = true;
            if (onCompleteParam != null)
                this._optional.onCompleteParam = onCompleteParam;
            return this;
        }

        /**
	* Pass an object to along with the onComplete Function
	* @method setOnCompleteParam
	* @param {object} onComplete:object an object that 
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.delayedCall(1.5f, enterMiniGameStart).setOnCompleteParam( new object[]{""+5} );<br><br>
	* void enterMiniGameStart( object val ){<br>
    * &nbsp;object[] arr = (object [])val;<br>
    * &nbsp;int lvl = int.Parse((string)arr[0]);<br>
    * }<br>
	*/

        public LTDescr setOnCompleteParam(object onCompleteParam)
        {
            this._optional.onCompleteParam = onCompleteParam;
            this.hasExtraOnCompletes = true;
            return this;
        }


        /**
	* Have a method called on each frame that the tween is being animated (passes a float value)
	* @method setOnUpdate
	* @param {Action<float>} onUpdate:Action<float> a method that will be called on every frame with the float value of the tweened object
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnUpdate( tweenMoved );<br>
	* <br>
	* void tweenMoved( float val ){ }<br>
	*/

        public LTDescr setOnUpdate(Action<float> onUpdate)
        {
            this._optional.onUpdateFloat = onUpdate;
            this.hasUpdateCallback = true;
            return this;
        }

        public LTDescr setOnUpdateRatio(Action<float, float> onUpdate)
        {
            this._optional.onUpdateFloatRatio = onUpdate;
            this.hasUpdateCallback = true;
            return this;
        }

        public LTDescr setOnUpdateObject(Action<float, object> onUpdate)
        {
            this._optional.onUpdateFloatObject = onUpdate;
            this.hasUpdateCallback = true;
            return this;
        }

        public LTDescr setOnUpdateVector2(Action<Vector2> onUpdate)
        {
            this._optional.onUpdateVector2 = onUpdate;
            this.hasUpdateCallback = true;
            return this;
        }

        public LTDescr setOnUpdateVector3(Action<Vector3> onUpdate)
        {
            this._optional.onUpdateVector3 = onUpdate;
            this.hasUpdateCallback = true;
            return this;
        }

        public LTDescr setOnUpdateColor(Action<Color> onUpdate)
        {
            this._optional.onUpdateColor = onUpdate;
            this.hasUpdateCallback = true;
            return this;
        }

        public LTDescr setOnUpdateColor(Action<Color, object> onUpdate)
        {
            this._optional.onUpdateColorObject = onUpdate;
            this.hasUpdateCallback = true;
            return this;
        }

#if !UNITY_FLASH

        public LTDescr setOnUpdate(Action<Color> onUpdate)
        {
            this._optional.onUpdateColor = onUpdate;
            this.hasUpdateCallback = true;
            return this;
        }

        public LTDescr setOnUpdate(Action<Color, object> onUpdate)
        {
            this._optional.onUpdateColorObject = onUpdate;
            this.hasUpdateCallback = true;
            return this;
        }

        /**
	* Have a method called on each frame that the tween is being animated (passes a float value and a object)
	* @method setOnUpdate (object)
	* @param {Action<float,object>} onUpdate:Action<float,object> a method that will be called on every frame with the float value of the tweened object, and an object of the person's choosing
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnUpdate( tweenMoved ).setOnUpdateParam( myObject );<br>
	* <br>
	* void tweenMoved( float val, object obj ){ }<br>
	*/

        public LTDescr setOnUpdate(Action<float, object> onUpdate, object onUpdateParam = null)
        {
            this._optional.onUpdateFloatObject = onUpdate;
            this.hasUpdateCallback = true;
            if (onUpdateParam != null)
                this._optional.onUpdateParam = onUpdateParam;
            return this;
        }

        public LTDescr setOnUpdate(Action<Vector3, object> onUpdate, object onUpdateParam = null)
        {
            this._optional.onUpdateVector3Object = onUpdate;
            this.hasUpdateCallback = true;
            if (onUpdateParam != null)
                this._optional.onUpdateParam = onUpdateParam;
            return this;
        }

        public LTDescr setOnUpdate(Action<Vector2> onUpdate, object onUpdateParam = null)
        {
            this._optional.onUpdateVector2 = onUpdate;
            this.hasUpdateCallback = true;
            if (onUpdateParam != null)
                this._optional.onUpdateParam = onUpdateParam;
            return this;
        }

        /**
	* Have a method called on each frame that the tween is being animated (passes a float value)
	* @method setOnUpdate (Vector3)
	* @param {Action<Vector3>} onUpdate:Action<Vector3> a method that will be called on every frame with the float value of the tweened object
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnUpdate( tweenMoved );<br>
	* <br>
	* void tweenMoved( Vector3 val ){ }<br>
	*/

        public LTDescr setOnUpdate(Action<Vector3> onUpdate, object onUpdateParam = null)
        {
            this._optional.onUpdateVector3 = onUpdate;
            this.hasUpdateCallback = true;
            if (onUpdateParam != null)
                this._optional.onUpdateParam = onUpdateParam;
            return this;
        }
#endif


        /**
	* Have an object passed along with the onUpdate method
	* @method setOnUpdateParam
	* @param {object} onUpdateParam:object an object that will be passed along with the onUpdate method
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnUpdate( tweenMoved ).setOnUpdateParam( myObject );<br>
	* <br>
	* void tweenMoved( float val, object obj ){ }<br>
	*/

        public LTDescr setOnUpdateParam(object onUpdateParam)
        {
            this._optional.onUpdateParam = onUpdateParam;
            return this;
        }

        /**
	* While tweening along a curve, set this property to true, to be perpendicalur to the path it is moving upon
	* @method setOrientToPath
	* @param {bool} doesOrient:bool whether the gameobject will orient to the path it is animating along
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.move( ltLogo, path, 1.0f ).setEase(LeanTweenType.easeOutQuad).setOrientToPath(true).setAxis(Vector3.forward);<br>
	*/

        public LTDescr setOrientToPath(bool doesOrient)
        {
            if (this.type == TweenAction.MOVE_CURVED || this.type == TweenAction.MOVE_CURVED_LOCAL)
            {
                if (this._optional.path == null)
                    this._optional.path = new LTBezierPath();
                this._optional.path.orientToPath = doesOrient;
            }
            else
            {
                this._optional.spline.orientToPath = doesOrient;
            }
            return this;
        }

        /**
	* While tweening along a curve, set this property to true, to be perpendicalur to the path it is moving upon
	* @method setOrientToPath2d
	* @param {bool} doesOrient:bool whether the gameobject will orient to the path it is animating along
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.move( ltLogo, path, 1.0f ).setEase(LeanTweenType.easeOutQuad).setOrientToPath2d(true).setAxis(Vector3.forward);<br>
	*/

        public LTDescr setOrientToPath2d(bool doesOrient2d)
        {
            setOrientToPath(doesOrient2d);
            if (this.type == TweenAction.MOVE_CURVED || this.type == TweenAction.MOVE_CURVED_LOCAL)
            {
                this._optional.path.orientToPath2d = doesOrient2d;
            }
            else
            {
                this._optional.spline.orientToPath2d = doesOrient2d;
            }
            return this;
        }

        public LTDescr setRect(LTRect rect)
        {
            this._optional.ltRect = rect;
            return this;
        }

        public LTDescr setRect(Rect rect)
        {
            this._optional.ltRect = new LTRect(rect);
            return this;
        }

        public LTDescr setPath(LTBezierPath path)
        {
            this._optional.path = path;
            return this;
        }

        /**
	* Set the point at which the GameObject will be rotated around
	* @method setPoint
	* @param {Vector3} point:Vector3 point at which you want the object to rotate around (local space)
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.rotateAround( cube, Vector3.up, 360.0f, 1.0f ) .setPoint( new Vector3(1f,0f,0f) ) .setEase( LeanTweenType.easeInOutBounce );<br>
	*/

        public LTDescr setPoint(Vector3 point)
        {
            this._optional.point = point;
            return this;
        }

        public LTDescr setDestroyOnComplete(bool doesDestroy)
        {
            this.destroyOnComplete = doesDestroy;
            return this;
        }

        public LTDescr setAudio(object audio)
        {
            this._optional.onCompleteParam = audio;
            return this;
        }

        /**
	* Set the onComplete method to be called at the end of every loop cycle (also applies to the delayedCall method)
	* @method setOnCompleteOnRepeat
	* @param {bool} isOn:bool does call onComplete on every loop cycle
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.delayedCall(gameObject,0.3f, delayedMethod).setRepeat(4).setOnCompleteOnRepeat(true);
	*/

        public LTDescr setOnCompleteOnRepeat(bool isOn)
        {
            this.onCompleteOnRepeat = isOn;
            return this;
        }

        /**
	* Set the onComplete method to be called at the beginning of the tween (it will still be called when it is completed as well)
	* @method setOnCompleteOnStart
	* @param {bool} isOn:bool does call onComplete at the start of the tween
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* LeanTween.delayedCall(gameObject, 2f, ()=>{<br> // Flash an object 5 times
	* &nbsp;LeanTween.alpha(gameObject, 0f, 1f);<br>
	* &nbsp;LeanTween.alpha(gameObject, 1f, 0f).setDelay(1f);<br>
	* }).setOnCompleteOnStart(true).setRepeat(5);<br>
	*/

        public LTDescr setOnCompleteOnStart(bool isOn)
        {
            this.onCompleteOnStart = isOn;
            return this;
        }

#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
        public LTDescr setRect(RectTransform rect)
        {
            this.rectTransform = rect;
            return this;
        }

        public LTDescr setSprites(UnityEngine.Sprite[] sprites)
        {
            this.sprites = sprites;
            return this;
        }

        public LTDescr setFrameRate(float frameRate)
        {
            this.time = this.sprites.Length/frameRate;
            return this;
        }
#endif

        /**
	* Have a method called when the tween starts
	* @method setOnStart
	* @param {Action<>} onStart:Action<> the method that should be called when the tween is starting ex: tweenStarted( ){ }
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
	* <i>C#:</i><br>
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnStart( ()=>{ Debug.Log("I started!"); });
	* <i>Javascript:</i><br>
	* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnStart( function(){ Debug.Log("I started!"); } );
	*/

        public LTDescr setOnStart(Action onStart)
        {
            this._optional.onStart = onStart;
            return this;
        }

        /**
	* Set the direction of a tween -1f for backwards 1f for forwards (currently only bezier and spline paths are supported)
	* @method setDirection
	* @param {float} direction:float the direction that the tween should run, -1f for backwards 1f for forwards
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
    * LeanTween.moveSpline(gameObject, new Vector3[]{new Vector3(0f,0f,0f),new Vector3(1f,0f,0f),new Vector3(1f,0f,0f),new Vector3(1f,0f,1f)}, 1.5f).setDirection(-1f);<br>
	*/

        public LTDescr setDirection(float direction)
        {
            if (this.direction != -1f && this.direction != 1f)
            {
                Debug.LogWarning("You have passed an incorrect direction of '" + direction +
                                 "', direction must be -1f or 1f");
                return this;
            }

            if (this.direction != direction)
            {
                // Debug.Log("reverse path:"+this.path+" spline:"+this._optional.spline+" hasInitiliazed:"+this.hasInitiliazed);
                if (this.hasInitiliazed)
                {
                    this.direction = direction;
                }
                else
                {
                    if (this._optional.path != null)
                    {
                        this._optional.path = new LTBezierPath(LTUtility.reverse(this._optional.path.pts));
                    }
                    else if (this._optional.spline != null)
                    {
                        this._optional.spline = new LTSpline(LTUtility.reverse(this._optional.spline.pts));
                    }
                    // this.passed = this.time - this.passed;
                }
            }

            return this;
        }

        /**
	* Set whether or not the tween will recursively effect an objects children in the hierarchy
	* @method setRecursive
	* @param {bool} useRecursion:bool whether the tween will recursively effect an objects children in the hierarchy
	* @return {LTDescr} LTDescr an object that distinguishes the tween
	* @example
    * LeanTween.alpha(gameObject, 0f, 1f).setRecursive(true);<br>
	*/

        public LTDescr setRecursive(bool useRecursion)
        {
            this.useRecursion = useRecursion;

            return this;
        }
    }
}

//}