public LTDescr setTextAlpha()
 {
     this.type = TweenAction.TEXT_ALPHA;
     this.initInternal = ()=>{
         this.uiText = trans.gameObject.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;
 }

//.........这里部分代码省略.........
							isTweenFinished = true;
							tween.passed = Mathf.Epsilon;
						}
					}

					if (!tween.hasInitiliazed && ((tween.passed == 0.0 && tween.delay == 0.0) || tween.passed > 0.0))
					{
						tween.init();
					}

					if (tween.delay <= 0)
					{
						// Move Values
						if (timeTotal <= 0f)
						{
							//Debug.LogError("time total is zero Time.timeScale:"+Time.timeScale+" useEstimatedTime:"+tween.useEstimatedTime);
							ratioPassed = 1f;
						}
						else
						{
							ratioPassed = tween.passed / timeTotal;
						}

						if (ratioPassed > 1.0f)
						{
							ratioPassed = 1.0f;
						}
						else if (ratioPassed < 0f)
						{
							ratioPassed = 0f;
						}
						// Debug.Log("action:"+tweenAction+" ratioPassed:"+ratioPassed + " timeTotal:" + timeTotal + " tween.passed:"+ tween.passed +" dt:"+dt);

						if (tweenAction >= TweenAction.MOVE_X && tweenAction < TweenAction.MOVE)
						{
							if (tween.animationCurve != null)
							{
								val = tweenOnCurve(tween, ratioPassed);
							}
							else
							{
								switch (tween.tweenType)
								{
									case LeanTweenType.linear:
										val = tween.from.x + tween.diff.x * ratioPassed; break;
									case LeanTweenType.easeOutQuad:
										val = easeOutQuadOpt(tween.from.x, tween.diff.x, ratioPassed); break;
									case LeanTweenType.easeInQuad:
										val = easeInQuadOpt(tween.from.x, tween.diff.x, ratioPassed); break;
									case LeanTweenType.easeInOutQuad:
										val = easeInOutQuadOpt(tween.from.x, tween.diff.x, ratioPassed); break;
									case LeanTweenType.easeInCubic:
										val = easeInCubic(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeOutCubic:
										val = easeOutCubic(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInOutCubic:
										val = easeInOutCubic(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInQuart:
										val = easeInQuart(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeOutQuart:
										val = easeOutQuart(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInOutQuart:
										val = easeInOutQuart(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInQuint:
										val = easeInQuint(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeOutQuint:

    private static LTDescr pushNewTween( GameObject gameObject, Vector3 to, float time, TweenAction tweenAction, LTDescr tween )
    {
        init(maxTweens);
        if(gameObject==null)
        return null;
        tween.trans = gameObject.transform;
        tween.to = to;
        tween.time = time;
        tween.type = tweenAction;
        //tween.hasPhysics = gameObject.rigidbody!=null;

        return tween;
    }

 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 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 setDelayedSound()
 {
     this.type = TweenAction.DELAYED_SOUND;
     this.initInternal = ()=>{ this.hasExtraOnCompletes = true; };
     this.easeInternal = this.callback;
     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 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;
 }

 public LTDescr setCanvasPlaySprite()
 {
     this.type = TweenAction.CANVAS_PLAYSPRITE;
     this.initInternal = ()=>{
         this.uiImage = trans.gameObject.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 setCanvasGroupAlpha()
 {
     this.type = TweenAction.CANVASGROUP_ALPHA;
     this.initInternal = ()=>{this.fromInternal.x = trans.gameObject.GetComponent<CanvasGroup>().alpha;};
     this.easeInternal = ()=>{ this.trans.GetComponent<CanvasGroup>().alpha = easeMethod().x; };
     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 setCanvasColor()
    {
        this.type = TweenAction.CANVAS_COLOR;
        this.initInternal = ()=>{
            this.uiImage = trans.gameObject.GetComponent<UnityEngine.UI.Image>();
            if(this.uiImage != null){
                this.setFromColor( this.uiImage.color );
            }else{
                this.setFromColor( Color.white );
            }
        };
        this.easeInternal = ()=>{
            newVect = easeMethod();
            val = newVect.x;
            Color toColor = tweenColor(this, val);
            this.uiImage.color = toColor;
            if (dt!=0f && this._optional.onUpdateColor != null)
                this._optional.onUpdateColor(toColor);

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

 public LTDescr setCanvasAlpha()
 {
     this.type = TweenAction.CANVAS_ALPHA;
     this.initInternal = ()=>{
         this.uiImage = trans.gameObject.GetComponent<UnityEngine.UI.Image>();
         this.fromInternal.x = this.uiImage != null ? this.uiImage.color.a : 1f;
     };
     this.easeInternal = ()=>{
         newVect = easeMethod();
         val = newVect.x;
         if(this.uiImage!=null){
             Color c = this.uiImage.color; c.a = val; this.uiImage.color = c;
         }
         if(this.useRecursion){
             alphaRecursive( this.rectTransform, val, 0 );
             textAlphaRecursive( this.rectTransform, val);
         }
     };
     return this;
 }

 public LTDescr setValue3()
 {
     this.type = TweenAction.VALUE3;
     this.initInternal = ()=>{};
     this.easeInternal = this.callback;
     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;
    }

    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 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.gameObject.GetComponent<SpriteRenderer>();
            if(renColor!=null){
                this.setFromColor( renColor.color );
            }else{
                if(trans.gameObject.GetComponent<Renderer>()!=null && trans.gameObject.GetComponent<Renderer>().material.HasProperty("_Color")){
                    Color col = trans.gameObject.GetComponent<Renderer>().material.color;
                    this.setFromColor( col );
                }else if(trans.gameObject.GetComponent<Renderer>()!=null && trans.gameObject.GetComponent<Renderer>().material.HasProperty("_TintColor")){
                    Color col = trans.gameObject.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 setCanvasScale()
 {
     this.type = TweenAction.CANVAS_SCALE;
     this.initInternal = ()=>{ this.from = this.rectTransform.localScale; };
     this.easeInternal = ()=>{ this.rectTransform.localScale = easeMethod(); };
     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 setCanvasSizeDelta()
 {
     this.type = TweenAction.CANVAS_SIZEDELTA;
     this.initInternal = ()=>{ this.from = this.rectTransform.sizeDelta; };
     this.easeInternal = ()=>{ this.rectTransform.sizeDelta = easeMethod(); };
     return this;
 }