Ejemplo n.º 1
0
    public static void update()
    {
        if(frameRendered != Time.frameCount){ // make sure update is only called once per frame
        init();

        dtEstimated = Time.realtimeSinceStartup - previousRealTime;
        if(dtEstimated>0.2f) // a catch put in, when at the start sometimes this number can grow unrealistically large
            dtEstimated = 0.2f;
        previousRealTime = Time.realtimeSinceStartup;
        dtActual = Time.deltaTime*Time.timeScale;
        // if(tweenMaxSearch>1500)
        // 	Debug.Log("tweenMaxSearch:"+tweenMaxSearch +" maxTweens:"+maxTweens);
        for( int i = 0; i < tweenMaxSearch && i < maxTweens; i++){

            //Debug.Log("tweens["+i+"].toggle:"+tweens[i].toggle);
            if(tweens[i].toggle){
                tween = tweens[i];
                trans = tween.trans;
                timeTotal = tween.time;
                tweenAction = tween.type;

                dt = dtActual;
                if( tween.useEstimatedTime ){
                    dt = dtEstimated;
                    timeTotal = tween.time;
                }else if( tween.useFrames ){
                    dt = 1;
                }else if(tween.direction==0f){
                    dt = 0f;
                }

                if(trans==null){
                    removeTween(i);
                    continue;
                }
                // Debug.Log("i:"+i+" tween:"+tween+" dt:"+dt);

                // Check for tween finished
                isTweenFinished = false;
                if(tween.delay<=0){
                    if((tween.passed + dt > timeTotal && tween.direction > 0.0f )){
                        isTweenFinished = true;
                        tween.passed = tween.time; // Set to the exact end time so that it can finish tween exactly on the end value
                    }else if(tween.direction<0.0f && tween.passed - dt < 0.0f){
                        isTweenFinished = true;
                        tween.passed = Mathf.Epsilon;
                    }
                }

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

                    // Set time based on current timeScale
                    if( !tween.useEstimatedTime ){
                        tween.time = tween.time*Time.timeScale;
                    }

                    // Initialize From Values
                    switch(tweenAction){
                        case TweenAction.MOVE:
                            tween.from = trans.position; break;
                        case TweenAction.MOVE_X:
                            tween.from.x = trans.position.x; break;
                        case TweenAction.MOVE_Y:
                            tween.from.x = trans.position.y; break;
                        case TweenAction.MOVE_Z:
                            tween.from.x = trans.position.z; break;
                        case TweenAction.MOVE_LOCAL_X:
                            tweens[i].from.x = trans.localPosition.x; break;
                        case TweenAction.MOVE_LOCAL_Y:
                            tweens[i].from.x = trans.localPosition.y; break;
                        case TweenAction.MOVE_LOCAL_Z:
                            tweens[i].from.x = trans.localPosition.z; break;
                        case TweenAction.SCALE_X:
                            tween.from.x = trans.localScale.x; break;
                        case TweenAction.SCALE_Y:
                            tween.from.x = trans.localScale.y; break;
                        case TweenAction.SCALE_Z:
                            tween.from.x = trans.localScale.z; break;
                        case TweenAction.ALPHA:
                            #if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
                                tween.from.x = trans.gameObject.renderer.material.color.a;
                                break;
                            #else
                                SpriteRenderer ren = trans.gameObject.GetComponent<SpriteRenderer>();
                                if(ren!=null){
                                    tween.from.x = ren.color.a;
                                }else if(trans.gameObject.renderer!=null){
                                    tween.from.x = trans.gameObject.renderer.material.color.a;
                                }
                                break;
                            #endif
                        case TweenAction.MOVE_LOCAL:
                            tween.from = trans.localPosition; break;
                        case TweenAction.MOVE_CURVED:
                        case TweenAction.MOVE_CURVED_LOCAL:
                        case TweenAction.MOVE_SPLINE:
                        case TweenAction.MOVE_SPLINE_LOCAL:
                            tween.from.x = 0; break;
                        case TweenAction.ROTATE:
                            tween.from = trans.eulerAngles;
                            tween.to = new Vector3(LeanTween.closestRot( tween.from.x, tween.to.x), LeanTween.closestRot( tween.from.y, tween.to.y), LeanTween.closestRot( tween.from.z, tween.to.z));
                            break;
                        case TweenAction.ROTATE_X:
                            tween.from.x = trans.eulerAngles.x;
                            tween.to.x = LeanTween.closestRot( tween.from.x, tween.to.x);
                            break;
                        case TweenAction.ROTATE_Y:
                            tween.from.x = trans.eulerAngles.y;
                            tween.to.x = LeanTween.closestRot( tween.from.x, tween.to.x);
                            break;
                        case TweenAction.ROTATE_Z:
                            tween.from.x = trans.eulerAngles.z;
                            tween.to.x = LeanTween.closestRot( tween.from.x, tween.to.x);
                            break;
                        case TweenAction.ROTATE_AROUND:
                            tween.lastVal = 0.0f; // optional["last"]
                            tween.from.x = 0.0f;
                            tween.origRotation = trans.rotation; // optional["origRotation"
                            break;
                        case TweenAction.ROTATE_AROUND_LOCAL:
                            tween.lastVal = 0.0f; // optional["last"]
                            tween.from.x = 0.0f;
                            tween.origRotation = trans.localRotation; // optional["origRotation"
                            break;
                        case TweenAction.ROTATE_LOCAL:
                            tween.from = trans.localEulerAngles;
                            tween.to = new Vector3(LeanTween.closestRot( tween.from.x, tween.to.x), LeanTween.closestRot( tween.from.y, tween.to.y), LeanTween.closestRot( tween.from.z, tween.to.z));
                            break;
                        case TweenAction.SCALE:
                            tween.from = trans.localScale; break;
                        case TweenAction.GUI_MOVE:
                            tween.from = new Vector3(tween.ltRect.rect.x, tween.ltRect.rect.y, 0); break;
                        case TweenAction.GUI_MOVE_MARGIN:
                            tween.from = new Vector2(tween.ltRect.margin.x, tween.ltRect.margin.y); break;
                        case TweenAction.GUI_SCALE:
                            tween.from = new  Vector3(tween.ltRect.rect.width, tween.ltRect.rect.height, 0); break;
                        case TweenAction.GUI_ALPHA:
                            tween.from.x = tween.ltRect.alpha; break;
                        case TweenAction.GUI_ROTATE:
                            if(tween.ltRect.rotateEnabled==false){
                                tween.ltRect.rotateEnabled = true;
                                tween.ltRect.resetForRotation();
                            }

                            tween.from.x = tween.ltRect.rotation; break;
                        case TweenAction.ALPHA_VERTEX:
                            tween.from.x = trans.GetComponent<MeshFilter>().mesh.colors32[0].a;
                            break;
                        case TweenAction.CALLBACK_COLOR:
                            tween.diff = new Vector3(1.0f,0.0f,0.0f);
                            break;
                        case TweenAction.COLOR:
                            #if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
                                if(trans.gameObject.renderer){
                                    Color col = trans.gameObject.renderer.material.color;
                                    tween.from = new Vector3(0.0f, col.a, 0.0f);
                                    tween.diff = new Vector3(1.0f,0.0f,0.0f);
                                    tween.axis = new Vector3( col.r, col.g, col.b );
                                }
                            #else
                                SpriteRenderer ren2 = trans.gameObject.GetComponent<SpriteRenderer>();
                                if(ren2!=null){
                                    tween.from = new Vector3(0.0f, ren2.color.a, 0.0f);
                                    tween.diff = new Vector3(1.0f,0.0f,0.0f);
                                    tween.axis = new Vector3( ren2.color.r, ren2.color.g, ren2.color.b );
                                }else if(trans.gameObject.renderer!=null){
                                    if(trans.gameObject.renderer){
                                        Color col = trans.gameObject.renderer.material.color;
                                        tween.from = new Vector3(0.0f, col.a, 0.0f);
                                        tween.diff = new Vector3(1.0f,0.0f,0.0f);
                                        tween.axis = new Vector3( col.r, col.g, col.b );
                                    }
                                }
                            #endif
                            break;
                    }
                    if(tweenAction!=TweenAction.CALLBACK_COLOR && tweenAction!=TweenAction.COLOR)
                        tween.diff = tween.to - tween.from;
                }
                if(tween.delay<=0){
                    // Move Values
                    if(timeTotal<=0f){
                        //Debug.LogError("time total is zero Time.timeScale:"+Time.timeScale+" useEstimatedTime:"+tween.useEstimatedTime);
                        ratioPassed = 0f;
                    }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.CALLBACK){
                        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:
                                    val = easeOutQuint(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInOutQuint:
                                    val = easeInOutQuint(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInSine:
                                    val = easeInSine(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeOutSine:
                                    val = easeOutSine(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInOutSine:
                                    val = easeInOutSine(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInExpo:
                                    val = easeInExpo(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeOutExpo:
                                    val = easeOutExpo(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInOutExpo:
                                    val = easeInOutExpo(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInCirc:
                                    val = easeInCirc(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeOutCirc:
                                    val = easeOutCirc(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInOutCirc:
                                    val = easeInOutCirc(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInBounce:
                                    val = easeInBounce(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeOutBounce:
                                    val = easeOutBounce(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInOutBounce:
                                    val = easeInOutBounce(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInBack:
                                    val = easeInBack(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeOutBack:
                                    val = easeOutBack(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInOutBack:
                                    val = easeInOutElastic(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInElastic:
                                    val = easeInElastic(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeOutElastic:
                                    val = easeOutElastic(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.easeInOutElastic:
                                    val = easeInOutElastic(tween.from.x, tween.to.x, ratioPassed); break;
                                case LeanTweenType.punch:
                                case LeanTweenType.easeShake:
                                    if(tween.tweenType==LeanTweenType.punch){
                                        tween.animationCurve = LeanTween.punch;
                                    }else if(tween.tweenType==LeanTweenType.easeShake){
                                        tween.animationCurve = LeanTween.shake;
                                    }
                                    tween.to.x = tween.from.x + tween.to.x;
                                    tween.diff.x = tween.to.x - tween.from.x;
                                    val = tweenOnCurve(tween, ratioPassed); break;
                                case LeanTweenType.easeSpring:
                                    val = spring(tween.from.x, tween.to.x, ratioPassed); break;
                                default:
                                    {
                                        val = tween.from.x + tween.diff.x * ratioPassed; break;
                                    }
                            }

                        }

                        //Debug.Log("from:"+from+" to:"+to+" val:"+val+" ratioPassed:"+ratioPassed);
                        if(tweenAction==TweenAction.MOVE_X){
                            trans.position=new Vector3( val,trans.position.y,trans.position.z);
                        }else if(tweenAction==TweenAction.MOVE_Y){
                            trans.position =new Vector3( trans.position.x,val,trans.position.z);
                        }else if(tweenAction==TweenAction.MOVE_Z){
                            trans.position=new Vector3( trans.position.x,trans.position.y,val);
                        }if(tweenAction==TweenAction.MOVE_LOCAL_X){
                            trans.localPosition=new Vector3( val,trans.localPosition.y,trans.localPosition.z);
                        }else if(tweenAction==TweenAction.MOVE_LOCAL_Y){
                            trans.localPosition=new Vector3( trans.localPosition.x,val,trans.localPosition.z);
                        }else if(tweenAction==TweenAction.MOVE_LOCAL_Z){
                            trans.localPosition=new Vector3( trans.localPosition.x,trans.localPosition.y,val);
                        }else if(tweenAction==TweenAction.MOVE_CURVED){
                            if(tween.path.orientToPath){
                                tween.path.place( trans, val );
                            }else{
                                trans.position = tween.path.point( val );
                            }
                            // Debug.Log("val:"+val+" trans.position:"+trans.position + " 0:"+ tween.curves[0] +" 1:"+tween.curves[1] +" 2:"+tween.curves[2] +" 3:"+tween.curves[3]);
                        }else if((TweenAction)tweenAction==TweenAction.MOVE_CURVED_LOCAL){
                            if(tween.path.orientToPath){
                                tween.path.placeLocal( trans, val );
                            }else{
                                trans.localPosition = tween.path.point( val );
                            }
                            // Debug.Log("val:"+val+" trans.position:"+trans.position);
                        }else if((TweenAction)tweenAction==TweenAction.MOVE_SPLINE){
                            if(tween.spline.orientToPath){
                                tween.spline.place( trans, val );
                            }else{
                                trans.position = tween.spline.point( val );
                            }
                        }else if((TweenAction)tweenAction==TweenAction.MOVE_SPLINE_LOCAL){
                            if(tween.spline.orientToPath){
                                tween.spline.placeLocal( trans, val );
                            }else{
                                trans.localPosition = tween.spline.point( val );
                            }
                        }else if(tweenAction==TweenAction.SCALE_X){
                            trans.localScale=new Vector3(val, trans.localScale.y,trans.localScale.z);
                        }else if(tweenAction==TweenAction.SCALE_Y){
                            trans.localScale=new Vector3( trans.localScale.x,val,trans.localScale.z);
                        }else if(tweenAction==TweenAction.SCALE_Z){
                            trans.localScale=new Vector3(trans.localScale.x,trans.localScale.y,val);
                        }else if(tweenAction==TweenAction.ROTATE_X){
                            trans.eulerAngles=new Vector3(val, trans.eulerAngles.y,trans.eulerAngles.z);
                        }else if(tweenAction==TweenAction.ROTATE_Y){
                            trans.eulerAngles=new Vector3(trans.eulerAngles.x,val,trans.eulerAngles.z);
                        }else if(tweenAction==TweenAction.ROTATE_Z){
                            trans.eulerAngles=new Vector3(trans.eulerAngles.x,trans.eulerAngles.y,val);
                        }else if(tweenAction==TweenAction.ROTATE_AROUND){

                            float move = val -  tween.lastVal;
                            // Debug.Log("move:"+move+" val:"+val + " timeTotal:"+timeTotal + " from:"+tween.from+ " diff:"+tween.diff);
                            if(isTweenFinished){
                                if(tween.direction>0){
                                    trans.rotation = tween.origRotation;
                                    trans.RotateAround((Vector3)trans.TransformPoint( tween.point ), tween.axis, tween.to.x);
                                }else{
                                    trans.rotation = tween.origRotation;
                                }
                            }else{
                                /*trans.rotation = tween.origRotation;
                                trans.RotateAround((Vector3)trans.TransformPoint( tween.point ), tween.axis, val);
                                tween.lastVal = val;*/

                                trans.RotateAround((Vector3)trans.TransformPoint( tween.point ), tween.axis, move);
                                tween.lastVal = val;

                                //trans.rotation =  * Quaternion.AngleAxis(val, tween.axis);
                            }

                        }else if(tweenAction==TweenAction.ROTATE_AROUND_LOCAL){
                            float move = val -  tween.lastVal;
                            if(isTweenFinished){
                                if(tween.direction>0){
                                    trans.localRotation = tween.origRotation;
                                trans.RotateAround((Vector3)trans.TransformPoint( tween.point ), trans.TransformDirection(tween.axis), tween.to.x);
                                }else{
                                    trans.localRotation = tween.origRotation;
                                }
                            }else{
                                trans.RotateAround((Vector3)trans.TransformPoint( tween.point ), trans.TransformDirection(tween.axis), move);
                                tween.lastVal = val;
                            }
                        }else if(tweenAction==TweenAction.ALPHA){
                            #if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2

                            foreach(Material mat in trans.gameObject.renderer.materials){
                                mat.color = new Color( mat.color.r, mat.color.g, mat.color.b, val);
                            }

                            #else

                            SpriteRenderer ren = trans.gameObject.GetComponent<SpriteRenderer>();
                            if(ren!=null){
                                ren.color = new Color( ren.color.r, ren.color.g, ren.color.b, val);
                            }else{
                                if(trans.gameObject.renderer!=null){
                                    foreach(Material mat in trans.gameObject.renderer.materials){
                                        mat.color = new Color( mat.color.r, mat.color.g, mat.color.b, val);
                                    }
                                }
                                if(trans.childCount>0){
                                    foreach (Transform child in trans) {
                                        if(child.gameObject.renderer!=null){
                                            foreach(Material mat in child.gameObject.renderer.materials){
                                                mat.color = new Color( mat.color.r, mat.color.g, mat.color.b, val);
                                            }
                                        }
                                    }
                                }
                            }

                            #endif
                        }else if(tweenAction==TweenAction.ALPHA_VERTEX){
                            Mesh mesh = trans.GetComponent<MeshFilter>().mesh;
                            Vector3[] vertices = mesh.vertices;
                            Color32[] colors = new Color32[vertices.Length];
                            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;
                        }else if(tweenAction==TweenAction.COLOR || tweenAction==TweenAction.CALLBACK_COLOR){
                            Color toColor = tweenColor(tween, val);
                            // Debug.Log("val:"+val+" tween:"+tween+" tween.diff:"+tween.diff);
                            if(tweenAction==TweenAction.COLOR){
                                if(trans.gameObject.renderer!=null){
                                    foreach(Material mat in trans.gameObject.renderer.materials){
                                        mat.color = toColor;
                                    }
                                }
                            }else if(tweenAction==TweenAction.CALLBACK_COLOR){
                                tween.onUpdateColor(toColor);
                            }
                        }

                    }else if(tweenAction>=TweenAction.MOVE){
                        //

                        if(tween.animationCurve!=null){
                            newVect = tweenOnCurveVector(tween, ratioPassed);
                        }else{
                            if(tween.tweenType == LeanTweenType.linear){
                                newVect = new Vector3( tween.from.x + tween.diff.x * ratioPassed, tween.from.y + tween.diff.y * ratioPassed, tween.from.z + tween.diff.z * ratioPassed);
                            }else if(tween.tweenType >= LeanTweenType.linear){
                                switch(tween.tweenType){
                                    case LeanTweenType.easeOutQuad:
                                        newVect = new Vector3(easeOutQuadOpt(tween.from.x, tween.diff.x, ratioPassed), easeOutQuadOpt(tween.from.y, tween.diff.y, ratioPassed), easeOutQuadOpt(tween.from.z, tween.diff.z, ratioPassed)); break;
                                    case LeanTweenType.easeInQuad:
                                        newVect = new Vector3(easeInQuadOpt(tween.from.x, tween.diff.x, ratioPassed), easeInQuadOpt(tween.from.y, tween.diff.y, ratioPassed), easeInQuadOpt(tween.from.z, tween.diff.z, ratioPassed)); break;
                                    case LeanTweenType.easeInOutQuad:
                                        newVect = new Vector3(easeInOutQuadOpt(tween.from.x, tween.diff.x, ratioPassed), easeInOutQuadOpt(tween.from.y, tween.diff.y, ratioPassed), easeInOutQuadOpt(tween.from.z, tween.diff.z, ratioPassed)); break;
                                    case LeanTweenType.easeInCubic:
                                        newVect = new Vector3(easeInCubic(tween.from.x, tween.to.x, ratioPassed), easeInCubic(tween.from.y, tween.to.y, ratioPassed), easeInCubic(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeOutCubic:
                                        newVect = new Vector3(easeOutCubic(tween.from.x, tween.to.x, ratioPassed), easeOutCubic(tween.from.y, tween.to.y, ratioPassed), easeOutCubic(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInOutCubic:
                                        newVect = new Vector3(easeInOutCubic(tween.from.x, tween.to.x, ratioPassed), easeInOutCubic(tween.from.y, tween.to.y, ratioPassed), easeInOutCubic(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInQuart:
                                        newVect = new Vector3(easeInQuart(tween.from.x, tween.to.x, ratioPassed), easeInQuart(tween.from.y, tween.to.y, ratioPassed), easeInQuart(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeOutQuart:
                                        newVect = new Vector3(easeOutQuart(tween.from.x, tween.to.x, ratioPassed), easeOutQuart(tween.from.y, tween.to.y, ratioPassed), easeOutQuart(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInOutQuart:
                                        newVect = new Vector3(easeInOutQuart(tween.from.x, tween.to.x, ratioPassed), easeInOutQuart(tween.from.y, tween.to.y, ratioPassed), easeInOutQuart(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInQuint:
                                        newVect = new Vector3(easeInQuint(tween.from.x, tween.to.x, ratioPassed), easeInQuint(tween.from.y, tween.to.y, ratioPassed), easeInQuint(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeOutQuint:
                                        newVect = new Vector3(easeOutQuint(tween.from.x, tween.to.x, ratioPassed), easeOutQuint(tween.from.y, tween.to.y, ratioPassed), easeOutQuint(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInOutQuint:
                                        newVect = new Vector3(easeInOutQuint(tween.from.x, tween.to.x, ratioPassed), easeInOutQuint(tween.from.y, tween.to.y, ratioPassed), easeInOutQuint(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInSine:
                                        newVect = new Vector3(easeInSine(tween.from.x, tween.to.x, ratioPassed), easeInSine(tween.from.y, tween.to.y, ratioPassed), easeInSine(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeOutSine:
                                        newVect = new Vector3(easeOutSine(tween.from.x, tween.to.x, ratioPassed), easeOutSine(tween.from.y, tween.to.y, ratioPassed), easeOutSine(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInOutSine:
                                        newVect = new Vector3(easeInOutSine(tween.from.x, tween.to.x, ratioPassed), easeInOutSine(tween.from.y, tween.to.y, ratioPassed), easeInOutSine(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInExpo:
                                        newVect = new Vector3(easeInExpo(tween.from.x, tween.to.x, ratioPassed), easeInExpo(tween.from.y, tween.to.y, ratioPassed), easeInExpo(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeOutExpo:
                                        newVect = new Vector3(easeOutExpo(tween.from.x, tween.to.x, ratioPassed), easeOutExpo(tween.from.y, tween.to.y, ratioPassed), easeOutExpo(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInOutExpo:
                                        newVect = new Vector3(easeInOutExpo(tween.from.x, tween.to.x, ratioPassed), easeInOutExpo(tween.from.y, tween.to.y, ratioPassed), easeInOutExpo(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInCirc:
                                        newVect = new Vector3(easeInCirc(tween.from.x, tween.to.x, ratioPassed), easeInCirc(tween.from.y, tween.to.y, ratioPassed), easeInCirc(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeOutCirc:
                                        newVect = new Vector3(easeOutCirc(tween.from.x, tween.to.x, ratioPassed), easeOutCirc(tween.from.y, tween.to.y, ratioPassed), easeOutCirc(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInOutCirc:
                                        newVect = new Vector3(easeInOutCirc(tween.from.x, tween.to.x, ratioPassed), easeInOutCirc(tween.from.y, tween.to.y, ratioPassed), easeInOutCirc(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInBounce:
                                        newVect = new Vector3(easeInBounce(tween.from.x, tween.to.x, ratioPassed), easeInBounce(tween.from.y, tween.to.y, ratioPassed), easeInBounce(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeOutBounce:
                                        newVect = new Vector3(easeOutBounce(tween.from.x, tween.to.x, ratioPassed), easeOutBounce(tween.from.y, tween.to.y, ratioPassed), easeOutBounce(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInOutBounce:
                                        newVect = new Vector3(easeInOutBounce(tween.from.x, tween.to.x, ratioPassed), easeInOutBounce(tween.from.y, tween.to.y, ratioPassed), easeInOutBounce(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInBack:
                                        newVect = new Vector3(easeInBack(tween.from.x, tween.to.x, ratioPassed), easeInBack(tween.from.y, tween.to.y, ratioPassed), easeInBack(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeOutBack:
                                        newVect = new Vector3(easeOutBack(tween.from.x, tween.to.x, ratioPassed), easeOutBack(tween.from.y, tween.to.y, ratioPassed), easeOutBack(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInOutBack:
                                        newVect = new Vector3(easeInOutBack(tween.from.x, tween.to.x, ratioPassed), easeInOutBack(tween.from.y, tween.to.y, ratioPassed), easeInOutBack(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInElastic:
                                        newVect = new Vector3(easeInElastic(tween.from.x, tween.to.x, ratioPassed), easeInElastic(tween.from.y, tween.to.y, ratioPassed), easeInElastic(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeOutElastic:
                                        newVect = new Vector3(easeOutElastic(tween.from.x, tween.to.x, ratioPassed), easeOutElastic(tween.from.y, tween.to.y, ratioPassed), easeOutElastic(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.easeInOutElastic:
                                        newVect = new Vector3(easeInOutElastic(tween.from.x, tween.to.x, ratioPassed), easeInOutElastic(tween.from.y, tween.to.y, ratioPassed), easeInOutElastic(tween.from.z, tween.to.z, ratioPassed)); break;
                                    case LeanTweenType.punch:
                                    case LeanTweenType.easeShake:
                                        if(tween.tweenType==LeanTweenType.punch){
                                            tween.animationCurve = LeanTween.punch;
                                        }else if(tween.tweenType==LeanTweenType.easeShake){
                                            tween.animationCurve = LeanTween.shake;
                                        }
                                        tween.to = tween.from + tween.to;
                                        tween.diff = tween.to - tween.from;
                                        if(tweenAction==TweenAction.ROTATE || tweenAction==TweenAction.ROTATE_LOCAL){
                                            tween.to = new Vector3(closestRot(tween.from.x, tween.to.x), closestRot(tween.from.y, tween.to.y), closestRot(tween.from.z, tween.to.z));
                                        }
                                        newVect = tweenOnCurveVector(tween, ratioPassed); break;
                                    case LeanTweenType.easeSpring:
                                        newVect = new Vector3(spring(tween.from.x, tween.to.x, ratioPassed), spring(tween.from.y, tween.to.y, ratioPassed), spring(tween.from.z, tween.to.z, ratioPassed)); break;

                                }
                            }else{
                                newVect = new Vector3( tween.from.x + tween.diff.x * ratioPassed, tween.from.y + tween.diff.y * ratioPassed, tween.from.z + tween.diff.z * ratioPassed);
                            }
                        }

                        if(tweenAction==TweenAction.MOVE){
                            trans.position = newVect;
                        }else if(tweenAction==TweenAction.MOVE_LOCAL){
                            trans.localPosition = newVect;
                        }else if(tweenAction==TweenAction.ROTATE){
                            /*if(tween.hasPhysics){
                                trans.gameObject.rigidbody.MoveRotation(Quaternion.Euler( newVect ));
                            }else{*/
                                trans.eulerAngles = newVect;
                            // }
                        }else if(tweenAction==TweenAction.ROTATE_LOCAL){
                            trans.localEulerAngles = newVect;
                        }else if(tweenAction==TweenAction.SCALE){
                            trans.localScale = newVect;
                        }else if(tweenAction==TweenAction.GUI_MOVE){
                            tween.ltRect.rect = new Rect( newVect.x, newVect.y, tween.ltRect.rect.width, tween.ltRect.rect.height);
                        }else if(tweenAction==TweenAction.GUI_MOVE_MARGIN){
                            tween.ltRect.margin = new Vector2(newVect.x, newVect.y);
                        }else if(tweenAction==TweenAction.GUI_SCALE){
                            tween.ltRect.rect = new Rect( tween.ltRect.rect.x, tween.ltRect.rect.y, newVect.x, newVect.y);
                        }else if(tweenAction==TweenAction.GUI_ALPHA){
                            tween.ltRect.alpha = newVect.x;
                        }else if(tweenAction==TweenAction.GUI_ROTATE){
                            tween.ltRect.rotation = newVect.x;
                        }
                    }
                    //Debug.Log("tween.delay:"+tween.delay + " tween.passed:"+tween.passed + " tweenAction:"+tweenAction + " to:"+newVect+" axis:"+tween.axis);

                    if(tween.onUpdateFloat!=null){
                        tween.onUpdateFloat(val);
                    }else if(tween.onUpdateFloatObject!=null){
                        tween.onUpdateFloatObject(val, tween.onUpdateParam);
                    }else if(tween.onUpdateVector3Object!=null){
                        tween.onUpdateVector3Object(newVect, tween.onUpdateParam);
                    }else if(tween.onUpdateVector3!=null){
                        tween.onUpdateVector3(newVect);
                    }
                    #if !UNITY_METRO
                    else if(tween.optional!=null){ // LeanTween 1.x legacy stuff

                        var onUpdate = tween.optional["onUpdate"];
                        if(onUpdate!=null){
                            Hashtable updateParam = (Hashtable)tween.optional["onUpdateParam"];
                            if((TweenAction)tweenAction==TweenAction.VALUE3){
                                if(onUpdate.GetType() == typeof(string)){
                                    string onUpdateS = onUpdate as string;
                                    customTarget = tween.optional["onUpdateTarget"]!=null ? tween.optional["onUpdateTarget"] as GameObject : trans.gameObject;
                                    customTarget.BroadcastMessage( onUpdateS, newVect );
                                }else if(onUpdate.GetType() == typeof(System.Action<Vector3, Hashtable>)){
                                    System.Action<Vector3, Hashtable> onUpdateA = (System.Action<Vector3, Hashtable>)onUpdate;
                                    onUpdateA(newVect, updateParam);
                                }else{
                                    System.Action<Vector3> onUpdateA = (System.Action<Vector3>)onUpdate;
                                    onUpdateA(newVect);
                                }
                            }else{
                                if(onUpdate.GetType() == typeof(string)){
                                    string onUpdateS = onUpdate as string;
                                    if (tween.optional["onUpdateTarget"]!=null){
                                        customTarget = tween.optional["onUpdateTarget"] as GameObject;
                                        customTarget.BroadcastMessage( onUpdateS, val );
                                    }else{
                                        trans.gameObject.BroadcastMessage( onUpdateS, val );
                                    }
                                }else if(onUpdate.GetType() == typeof(System.Action<float, Hashtable>)){
                                    System.Action<float, Hashtable> onUpdateA = (System.Action<float, Hashtable>)onUpdate;
                                    onUpdateA(val, updateParam);
                                }else if(onUpdate.GetType() == typeof(System.Action<Vector3>)){
                                    System.Action<Vector3> onUpdateA = (System.Action<Vector3>)onUpdate;
                                    onUpdateA( newVect );
                                }else{
                                    System.Action<float> onUpdateA = (System.Action<float>)onUpdate;
                                    onUpdateA(val);
                                }
                            }
                        }
                    }
                    #endif
                }

                if(isTweenFinished){
                    // Debug.Log("finished tween:"+i+" tween:"+tween);
                    if(tweenAction==TweenAction.GUI_ROTATE)
                        tween.ltRect.rotateFinished = true;

                    if(tween.loopType==LeanTweenType.once || tween.loopCount==1){
                        if(tweenAction==TweenAction.DELAYED_SOUND){
                            AudioSource.PlayClipAtPoint((AudioClip)tween.onCompleteParam, tween.to, tween.from.x);
                        }
                        if(tween.onComplete!=null){
                            removeTween(i);
                            tween.onComplete();

                        }else if(tween.onCompleteObject!=null){
                            removeTween(i);
                            tween.onCompleteObject(tween.onCompleteParam);
                        }

                        #if !UNITY_METRO
                        else if(tween.optional!=null){
                            System.Action callback=null;
                            System.Action<object> callbackWithParam = null;
                            string callbackS=string.Empty;
                            object callbackParam=null;
                            if(tween.optional!=null && tween.trans){
                                if(tween.optional["onComplete"]!=null){
                                    callbackParam = tween.optional["onCompleteParam"];
                                    if(tween.optional["onComplete"].GetType()==typeof(string)){
                                        callbackS = tween.optional["onComplete"] as string;
                                    }else{
                                        if(callbackParam!=null){
                                            callbackWithParam = (System.Action<object>)tween.optional["onComplete"];
                                        }else{
                                            callback = (System.Action)tween.optional["onComplete"];
                                            if(callback==null)
                                                Debug.LogWarning("callback was not converted");
                                        }
                                    }
                                }
                            }
                            removeTween(i);
                            if(callbackWithParam!=null){
                                callbackWithParam( callbackParam );
                            }else if(callback!=null){
                                callback();
                            }else if(callbackS!=string.Empty){
                                if (tween.optional["onCompleteTarget"]!=null){
                                    customTarget = tween.optional["onCompleteTarget"] as GameObject;
                                    if(callbackParam!=null) customTarget.BroadcastMessage ( callbackS, callbackParam );
                                    else customTarget.BroadcastMessage( callbackS );
                                }else{
                                    if(callbackParam!=null) trans.gameObject.BroadcastMessage ( callbackS, callbackParam );
                                    else trans.gameObject.BroadcastMessage( callbackS );
                                }
                            }
                        }
                        #endif
                        else{
                            removeTween(i);
                        }
                    }else{
                        if((tween.loopCount<0 && tween.type==TweenAction.CALLBACK) || tween.onCompleteOnRepeat){
                            if(tweenAction==TweenAction.DELAYED_SOUND){
                                AudioSource.PlayClipAtPoint((AudioClip)tween.onCompleteParam, tween.to, tween.from.x);
                            }
                            if(tween.onComplete!=null){
                                tween.onComplete();
                            }else if(tween.onCompleteObject!=null){
                                tween.onCompleteObject(tween.onCompleteParam);
                            }
                        }
                        if(tween.loopCount>=1){
                            tween.loopCount--;
                        }
                        if(tween.loopType==LeanTweenType.clamp){
                            tween.passed = Mathf.Epsilon;
                            // tween.delay = 0.0;
                        }else if(tween.loopType==LeanTweenType.pingPong){
                            tween.direction = 0.0f-(tween.direction);
                        }
                    }
                }else if(tween.delay<=0){
                    tween.passed += dt*tween.direction;
                }else{
                    tween.delay -= dt;
                    // Debug.Log("dt:"+dt+" tween:"+i+" tween:"+tween);
                    if(tween.delay<0){
                        tween.passed = 0.0f;//-tween.delay
                        tween.delay = 0.0f;
                    }
                }
            }
        }

        frameRendered = Time.frameCount;
        }
    }
	public static void update()
	{
		if (frameRendered != Time.frameCount)
		{ // make sure update is only called once per frame
			init();

#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_5
		dtEstimated = Time.realtimeSinceStartup - previousRealTime;
		if(dtEstimated>0.2f) // a catch put in, when at the start sometimes this number can grow unrealistically large
			dtEstimated = 0.2f;
		previousRealTime = Time.realtimeSinceStartup;
#else
			dtEstimated = Time.unscaledDeltaTime;
#endif

			dtActual = Time.deltaTime;
			maxTweenReached = 0;
			finishedCnt = 0;
			// if(tweenMaxSearch>1500)
			// Debug.Log("tweenMaxSearch:"+tweenMaxSearch +" maxTweens:"+maxTweens);
			for (int i = 0; i <= tweenMaxSearch && i < maxTweens; i++)
			{

				//if(i==0 && tweens[i].toggle)
				//	Debug.Log("tweens["+i+"]"+tweens[i]+" dt:"+dt);
				if (tweens[i].toggle)
				{
					maxTweenReached = i;
					tween = tweens[i];
					trans = tween.trans;
					timeTotal = tween.time;
					tweenAction = tween.type;

					/*if(trans.gameObject.name=="Main Camera"){
						Debug.Log("main tween:"+tween+" i:"+i);
					}*/

					if (tween.useEstimatedTime)
					{
						dt = dtEstimated;
					}
					else if (tween.useFrames)
					{
						dt = 1;
					}
					else if (tween.useManualTime)
					{
						dt = dtManual;
					}
					else if (tween.direction == 0f)
					{
						dt = 0f;
					}
					else
					{
						dt = dtActual;
					}

					if (trans == null)
					{
						removeTween(i);
						continue;
					}
					// Debug.Log("i:"+i+" tween:"+tween+" dt:"+dt);

					// Check for tween finished
					isTweenFinished = false;
					if (tween.delay <= 0)
					{
						if ((tween.passed + dt > tween.time && tween.direction > 0.0f))
						{
							// Debug.Log("i:"+i+" passed:"+tween.passed+" dt:"+dt+" time:"+tween.time+" dir:"+tween.direction);
							isTweenFinished = true;
							tween.passed = tween.time; // Set to the exact end time so that it can finish tween exactly on the end value
						}
						else if (tween.direction < 0.0f && tween.passed - dt < 0.0f)
						{
							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:
										val = easeOutQuint(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInOutQuint:
										val = easeInOutQuint(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInSine:
										val = easeInSine(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeOutSine:
										val = easeOutSine(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInOutSine:
										val = easeInOutSine(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInExpo:
										val = easeInExpo(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeOutExpo:
										val = easeOutExpo(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInOutExpo:
										val = easeInOutExpo(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInCirc:
										val = easeInCirc(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeOutCirc:
										val = easeOutCirc(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInOutCirc:
										val = easeInOutCirc(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInBounce:
										val = easeInBounce(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeOutBounce:
										val = easeOutBounce(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInOutBounce:
										val = easeInOutBounce(tween.from.x, tween.to.x, ratioPassed); break;
									case LeanTweenType.easeInBack:
										val = easeInBack(tween.from.x, tween.to.x, ratioPassed, tween.overshoot); break;
									case LeanTweenType.easeOutBack:
										val = easeOutBack(tween.from.x, tween.to.x, ratioPassed, tween.overshoot); break;
									case LeanTweenType.easeInOutBack:
										val = easeInOutBack(tween.from.x, tween.to.x, ratioPassed, tween.overshoot); break;
									case LeanTweenType.easeInElastic:
										val = easeInElastic(tween.from.x, tween.to.x, ratioPassed, tween.overshoot, tween.period); break;
									case LeanTweenType.easeOutElastic:
										val = easeOutElastic(tween.from.x, tween.to.x, ratioPassed, tween.overshoot, tween.period); break;
									case LeanTweenType.easeInOutElastic:
										val = easeInOutElastic(tween.from.x, tween.to.x, ratioPassed, tween.overshoot, tween.period); break;
									case LeanTweenType.punch:
									case LeanTweenType.easeShake:
										if (tween.tweenType == LeanTweenType.punch)
										{
											tween.animationCurve = LeanTween.punch;
										}
										else if (tween.tweenType == LeanTweenType.easeShake)
										{
											tween.animationCurve = LeanTween.shake;
										}
										tween.to.x = tween.from.x + tween.to.x;
										tween.diff.x = tween.to.x - tween.from.x;
										val = tweenOnCurve(tween, ratioPassed); break;
									case LeanTweenType.easeSpring:
										val = spring(tween.from.x, tween.to.x, ratioPassed); break;
									default:
										{
											val = tween.from.x + tween.diff.x * ratioPassed; break;
										}
								}

							}

							// Debug.Log("from:"+from+" val:"+val+" ratioPassed:"+ratioPassed);
							if (tweenAction == TweenAction.MOVE_X)
							{
								trans.position = new Vector3(val, trans.position.y, trans.position.z);
							}
							else if (tweenAction == TweenAction.MOVE_Y)
							{
								trans.position = new Vector3(trans.position.x, val, trans.position.z);
							}
							else if (tweenAction == TweenAction.MOVE_Z)
							{
								trans.position = new Vector3(trans.position.x, trans.position.y, val);
							}
							if (tweenAction == TweenAction.MOVE_LOCAL_X)
							{
								trans.localPosition = new Vector3(val, trans.localPosition.y, trans.localPosition.z);
							}
							else if (tweenAction == TweenAction.MOVE_LOCAL_Y)
							{
								trans.localPosition = new Vector3(trans.localPosition.x, val, trans.localPosition.z);
							}
							else if (tweenAction == TweenAction.MOVE_LOCAL_Z)
							{
								trans.localPosition = new Vector3(trans.localPosition.x, trans.localPosition.y, val);
							}
							else if (tweenAction == TweenAction.MOVE_CURVED)
							{
								if (tween.path.orientToPath)
								{
									if (tween.path.orientToPath2d)
									{
										tween.path.place2d(trans, val);
									}
									else
									{
										tween.path.place(trans, val);
									}
								}
								else
								{
									trans.position = tween.path.point(val);
								}
								// Debug.Log("val:"+val+" trans.position:"+trans.position + " 0:"+ tween.curves[0] +" 1:"+tween.curves[1] +" 2:"+tween.curves[2] +" 3:"+tween.curves[3]);
							}
							else if ((TweenAction)tweenAction == TweenAction.MOVE_CURVED_LOCAL)
							{
								if (tween.path.orientToPath)
								{
									if (tween.path.orientToPath2d)
									{
										tween.path.placeLocal2d(trans, val);
									}
									else
									{
										tween.path.placeLocal(trans, val);
									}
								}
								else
								{
									trans.localPosition = tween.path.point(val);
								}
								// Debug.Log("val:"+val+" trans.position:"+trans.position);
							}
							else if (tweenAction == TweenAction.MOVE_SPLINE)
							{
								if (tween.spline.orientToPath)
								{
									if (tween.spline.orientToPath2d)
									{
										tween.spline.place2d(trans, val);
									}
									else
									{
										tween.spline.place(trans, val);
									}
								}
								else
								{
									trans.position = tween.spline.point(val);
								}
							}
							else if (tweenAction == TweenAction.MOVE_SPLINE_LOCAL)
							{
								if (tween.spline.orientToPath)
								{
									if (tween.spline.orientToPath2d)
									{
										tween.spline.placeLocal2d(trans, val);
									}
									else
									{
										tween.spline.placeLocal(trans, val);
									}
								}
								else
								{
									trans.localPosition = tween.spline.point(val);
								}
							}
							else if (tweenAction == TweenAction.SCALE_X)
							{
								trans.localScale = new Vector3(val, trans.localScale.y, trans.localScale.z);
							}
							else if (tweenAction == TweenAction.SCALE_Y)
							{
								trans.localScale = new Vector3(trans.localScale.x, val, trans.localScale.z);
							}
							else if (tweenAction == TweenAction.SCALE_Z)
							{
								trans.localScale = new Vector3(trans.localScale.x, trans.localScale.y, val);
							}
							else if (tweenAction == TweenAction.ROTATE_X)
							{
								trans.eulerAngles = new Vector3(val, trans.eulerAngles.y, trans.eulerAngles.z);
							}
							else if (tweenAction == TweenAction.ROTATE_Y)
							{
								trans.eulerAngles = new Vector3(trans.eulerAngles.x, val, trans.eulerAngles.z);
							}
							else if (tweenAction == TweenAction.ROTATE_Z)
							{
								trans.eulerAngles = new Vector3(trans.eulerAngles.x, trans.eulerAngles.y, val);
							}
							else if (tweenAction == TweenAction.ROTATE_AROUND)
							{
								Vector3 origPos = trans.localPosition;
								Vector3 rotateAroundPt = (Vector3)trans.TransformPoint(tween.point);
								trans.RotateAround(rotateAroundPt, tween.axis, -val);
								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 = tween.origRotation;

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

								//GameObject cubeMarker = GameObject.Find("TweenRotatePoint");
								//cubeMarker.transform.position = rotateAroundPt;

							}
							else if (tweenAction == TweenAction.ROTATE_AROUND_LOCAL)
							{
								Vector3 origPos = trans.localPosition;
								trans.RotateAround((Vector3)trans.TransformPoint(tween.point), trans.TransformDirection(tween.axis), -val);
								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 = tween.origRotation;
								Vector3 rotateAroundPt = (Vector3)trans.TransformPoint(tween.point);
								trans.RotateAround(rotateAroundPt, trans.TransformDirection(tween.axis), val);

								//GameObject cubeMarker = GameObject.Find("TweenRotatePoint");
								//cubeMarker.transform.position = rotateAroundPt;

							}
							else if (tweenAction == TweenAction.ALPHA)
							{
#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2

					    	if(trans.gameObject.renderer){
								foreach(Material mat in trans.gameObject.renderer.materials){
	        						mat.color = new Color( mat.color.r, mat.color.g, mat.color.b, val);
	    						}
							}
							if(trans.childCount>0){
								foreach (Transform child in trans) {
									if(child.gameObject.renderer!=null){
										foreach(Material mat in child.gameObject.renderer.materials){
			        						mat.color = new Color( mat.color.r, mat.color.g, mat.color.b, val);
			    						}
			    					}
								}
							}

#else

								SpriteRenderer ren = trans.gameObject.GetComponent<SpriteRenderer>();

								if (ren != null)
								{
									ren.color = new Color(ren.color.r, ren.color.g, ren.color.b, val);
								}
								else
								{
									if (trans.gameObject.GetComponent<Renderer>() != null)
									{
										foreach (Material mat in trans.gameObject.GetComponent<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 (trans.childCount > 0)
									{
										foreach (Transform child in trans)
										{
											if (child.gameObject.GetComponent<Renderer>() != null)
											{
												foreach (Material mat in child.gameObject.GetComponent<Renderer>().materials)
												{
													mat.color = new Color(mat.color.r, mat.color.g, mat.color.b, val);
												}
											}
										}
									}
								}

#endif
							}
							else if (tweenAction == TweenAction.ALPHA_VERTEX)
							{
								Mesh mesh = trans.GetComponent<MeshFilter>().mesh;
								Vector3[] vertices = mesh.vertices;
								Color32[] colors = new Color32[vertices.Length];
								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;
							}
							else if (tweenAction == TweenAction.COLOR || tweenAction == TweenAction.CALLBACK_COLOR)
							{
								Color toColor = tweenColor(tween, val);

#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
								SpriteRenderer ren = trans.gameObject.GetComponent<SpriteRenderer>();
								if (ren != null)
								{
									ren.color = toColor;
								}
								else
								{
#endif
									// Debug.Log("val:"+val+" tween:"+tween+" tween.diff:"+tween.diff);
									if (tweenAction == TweenAction.COLOR)
									{
										if (trans.gameObject.GetComponent<Renderer>() != null)
										{
											foreach (Material mat in trans.gameObject.GetComponent<Renderer>().materials)
											{
												mat.color = toColor;
											}
										}
										if (trans.childCount > 0)
										{
											foreach (Transform child in trans)
											{
												if (child.gameObject.GetComponent<Renderer>() != null)
												{
													foreach (Material mat in child.gameObject.GetComponent<Renderer>().materials)
													{
														mat.color = toColor;
													}
												}
											}
										}
									}
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
								}
#endif
								if (dt != 0f && tween.onUpdateColor != null)
								{
									tween.onUpdateColor(toColor);
								}
							}
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
							else if (tweenAction == TweenAction.CANVAS_ALPHA)
							{
								Color c = tween.uiImage.color;
								c.a = val;
								tween.uiImage.color = c;
							}
							else if (tweenAction == TweenAction.CANVAS_COLOR)
							{
								Color toColor = tweenColor(tween, val);
								tween.uiImage.color = toColor;
								if (dt != 0f && tween.onUpdateColor != null)
								{
									tween.onUpdateColor(toColor);
								}
							}
							else if (tweenAction == TweenAction.TEXT_ALPHA)
							{
								textAlphaRecursive(trans, val);
							}
							else if (tweenAction == TweenAction.TEXT_COLOR)
							{
								Color toColor = tweenColor(tween, val);
								tween.uiText.color = toColor;
								if (dt != 0f && tween.onUpdateColor != null)
								{
									tween.onUpdateColor(toColor);
								}
								if (trans.childCount > 0)
								{
									foreach (Transform child in trans)
									{
										UnityEngine.UI.Text uiText = child.gameObject.GetComponent<UnityEngine.UI.Text>();
										if (uiText != null)
										{
											uiText.color = toColor;
										}
									}
								}
							}
							else if (tweenAction == TweenAction.CANVAS_ROTATEAROUND)
							{
								// figure out how much the rotation has shifted the object over
								RectTransform rect = tween.rectTransform;
								Vector3 origPos = rect.localPosition;
								rect.RotateAround((Vector3)rect.TransformPoint(tween.point), tween.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 = tween.origRotation;
								rect.RotateAround((Vector3)rect.TransformPoint(tween.point), tween.axis, val);
							}
							else if (tweenAction == TweenAction.CANVAS_ROTATEAROUND_LOCAL)
							{
								// figure out how much the rotation has shifted the object over
								RectTransform rect = tween.rectTransform;
								Vector3 origPos = rect.localPosition;
								rect.RotateAround((Vector3)rect.TransformPoint(tween.point), rect.TransformDirection(tween.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 = tween.origRotation;
								rect.RotateAround((Vector3)rect.TransformPoint(tween.point), rect.TransformDirection(tween.axis), val);
							}
							else if (tweenAction == TweenAction.CANVAS_PLAYSPRITE)
							{
								int frame = (int)Mathf.Round(val);
								// Debug.Log("frame:"+frame+" val:"+val);
								tween.uiImage.sprite = tween.sprites[frame];
							}
							else if (tweenAction == TweenAction.CANVAS_MOVE_X)
							{
								Vector3 current = tween.rectTransform.anchoredPosition3D;
								tween.rectTransform.anchoredPosition3D = new Vector3(val, current.y, current.z);
							}
							else if (tweenAction == TweenAction.CANVAS_MOVE_Y)
							{
								Vector3 current = tween.rectTransform.anchoredPosition3D;
								tween.rectTransform.anchoredPosition3D = new Vector3(current.x, val, current.z);
							}
							else if (tweenAction == TweenAction.CANVAS_MOVE_Z)
							{
								Vector3 current = tween.rectTransform.anchoredPosition3D;
								tween.rectTransform.anchoredPosition3D = new Vector3(current.x, current.y, val);
							}
#endif

						}
						else if (tweenAction >= TweenAction.MOVE)
						{
							//

							if (tween.animationCurve != null)
							{
								newVect = tweenOnCurveVector(tween, ratioPassed);
							}
							else
							{
								if (tween.tweenType == LeanTweenType.linear)
								{
									newVect = new Vector3(tween.from.x + tween.diff.x * ratioPassed, tween.from.y + tween.diff.y * ratioPassed, tween.from.z + tween.diff.z * ratioPassed);
								}
								else if (tween.tweenType >= LeanTweenType.linear)
								{
									switch (tween.tweenType)
									{
										case LeanTweenType.easeOutQuad:
											newVect = new Vector3(easeOutQuadOpt(tween.from.x, tween.diff.x, ratioPassed), easeOutQuadOpt(tween.from.y, tween.diff.y, ratioPassed), easeOutQuadOpt(tween.from.z, tween.diff.z, ratioPassed)); break;
										case LeanTweenType.easeInQuad:
											newVect = new Vector3(easeInQuadOpt(tween.from.x, tween.diff.x, ratioPassed), easeInQuadOpt(tween.from.y, tween.diff.y, ratioPassed), easeInQuadOpt(tween.from.z, tween.diff.z, ratioPassed)); break;
										case LeanTweenType.easeInOutQuad:
											newVect = new Vector3(easeInOutQuadOpt(tween.from.x, tween.diff.x, ratioPassed), easeInOutQuadOpt(tween.from.y, tween.diff.y, ratioPassed), easeInOutQuadOpt(tween.from.z, tween.diff.z, ratioPassed)); break;
										case LeanTweenType.easeInCubic:
											newVect = new Vector3(easeInCubic(tween.from.x, tween.to.x, ratioPassed), easeInCubic(tween.from.y, tween.to.y, ratioPassed), easeInCubic(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeOutCubic:
											newVect = new Vector3(easeOutCubic(tween.from.x, tween.to.x, ratioPassed), easeOutCubic(tween.from.y, tween.to.y, ratioPassed), easeOutCubic(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInOutCubic:
											newVect = new Vector3(easeInOutCubic(tween.from.x, tween.to.x, ratioPassed), easeInOutCubic(tween.from.y, tween.to.y, ratioPassed), easeInOutCubic(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInQuart:
											newVect = new Vector3(easeInQuart(tween.from.x, tween.to.x, ratioPassed), easeInQuart(tween.from.y, tween.to.y, ratioPassed), easeInQuart(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeOutQuart:
											newVect = new Vector3(easeOutQuart(tween.from.x, tween.to.x, ratioPassed), easeOutQuart(tween.from.y, tween.to.y, ratioPassed), easeOutQuart(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInOutQuart:
											newVect = new Vector3(easeInOutQuart(tween.from.x, tween.to.x, ratioPassed), easeInOutQuart(tween.from.y, tween.to.y, ratioPassed), easeInOutQuart(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInQuint:
											newVect = new Vector3(easeInQuint(tween.from.x, tween.to.x, ratioPassed), easeInQuint(tween.from.y, tween.to.y, ratioPassed), easeInQuint(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeOutQuint:
											newVect = new Vector3(easeOutQuint(tween.from.x, tween.to.x, ratioPassed), easeOutQuint(tween.from.y, tween.to.y, ratioPassed), easeOutQuint(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInOutQuint:
											newVect = new Vector3(easeInOutQuint(tween.from.x, tween.to.x, ratioPassed), easeInOutQuint(tween.from.y, tween.to.y, ratioPassed), easeInOutQuint(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInSine:
											newVect = new Vector3(easeInSine(tween.from.x, tween.to.x, ratioPassed), easeInSine(tween.from.y, tween.to.y, ratioPassed), easeInSine(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeOutSine:
											newVect = new Vector3(easeOutSine(tween.from.x, tween.to.x, ratioPassed), easeOutSine(tween.from.y, tween.to.y, ratioPassed), easeOutSine(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInOutSine:
											newVect = new Vector3(easeInOutSine(tween.from.x, tween.to.x, ratioPassed), easeInOutSine(tween.from.y, tween.to.y, ratioPassed), easeInOutSine(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInExpo:
											newVect = new Vector3(easeInExpo(tween.from.x, tween.to.x, ratioPassed), easeInExpo(tween.from.y, tween.to.y, ratioPassed), easeInExpo(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeOutExpo:
											newVect = new Vector3(easeOutExpo(tween.from.x, tween.to.x, ratioPassed), easeOutExpo(tween.from.y, tween.to.y, ratioPassed), easeOutExpo(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInOutExpo:
											newVect = new Vector3(easeInOutExpo(tween.from.x, tween.to.x, ratioPassed), easeInOutExpo(tween.from.y, tween.to.y, ratioPassed), easeInOutExpo(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInCirc:
											newVect = new Vector3(easeInCirc(tween.from.x, tween.to.x, ratioPassed), easeInCirc(tween.from.y, tween.to.y, ratioPassed), easeInCirc(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeOutCirc:
											newVect = new Vector3(easeOutCirc(tween.from.x, tween.to.x, ratioPassed), easeOutCirc(tween.from.y, tween.to.y, ratioPassed), easeOutCirc(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInOutCirc:
											newVect = new Vector3(easeInOutCirc(tween.from.x, tween.to.x, ratioPassed), easeInOutCirc(tween.from.y, tween.to.y, ratioPassed), easeInOutCirc(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInBounce:
											newVect = new Vector3(easeInBounce(tween.from.x, tween.to.x, ratioPassed), easeInBounce(tween.from.y, tween.to.y, ratioPassed), easeInBounce(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeOutBounce:
											newVect = new Vector3(easeOutBounce(tween.from.x, tween.to.x, ratioPassed), easeOutBounce(tween.from.y, tween.to.y, ratioPassed), easeOutBounce(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInOutBounce:
											newVect = new Vector3(easeInOutBounce(tween.from.x, tween.to.x, ratioPassed), easeInOutBounce(tween.from.y, tween.to.y, ratioPassed), easeInOutBounce(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeInBack:
											newVect = new Vector3(easeInBack(tween.from.x, tween.to.x, ratioPassed), easeInBack(tween.from.y, tween.to.y, ratioPassed), easeInBack(tween.from.z, tween.to.z, ratioPassed)); break;
										case LeanTweenType.easeOutBack:
											newVect = new Vector3(easeOutBack(tween.from.x, tween.to.x, ratioPassed, tween.overshoot), easeOutBack(tween.from.y, tween.to.y, ratioPassed, tween.overshoot), easeOutBack(tween.from.z, tween.to.z, ratioPassed, tween.overshoot)); break;
										case LeanTweenType.easeInOutBack:
											newVect = new Vector3(easeInOutBack(tween.from.x, tween.to.x, ratioPassed, tween.overshoot), easeInOutBack(tween.from.y, tween.to.y, ratioPassed, tween.overshoot), easeInOutBack(tween.from.z, tween.to.z, ratioPassed, tween.overshoot)); break;
										case LeanTweenType.easeInElastic:
											newVect = new Vector3(easeInElastic(tween.from.x, tween.to.x, ratioPassed, tween.overshoot, tween.period), easeInElastic(tween.from.y, tween.to.y, ratioPassed, tween.overshoot, tween.period), easeInElastic(tween.from.z, tween.to.z, ratioPassed, tween.overshoot, tween.period)); break;
										case LeanTweenType.easeOutElastic:
											newVect = new Vector3(easeOutElastic(tween.from.x, tween.to.x, ratioPassed, tween.overshoot, tween.period), easeOutElastic(tween.from.y, tween.to.y, ratioPassed, tween.overshoot, tween.period), easeOutElastic(tween.from.z, tween.to.z, ratioPassed, tween.overshoot, tween.period)); break;
										case LeanTweenType.easeInOutElastic:
											newVect = new Vector3(easeInOutElastic(tween.from.x, tween.to.x, ratioPassed, tween.overshoot, tween.period), easeInOutElastic(tween.from.y, tween.to.y, ratioPassed, tween.overshoot, tween.period), easeInOutElastic(tween.from.z, tween.to.z, ratioPassed, tween.overshoot, tween.period)); break;
										case LeanTweenType.punch:
										case LeanTweenType.easeShake:
											if (tween.tweenType == LeanTweenType.punch)
											{
												tween.animationCurve = LeanTween.punch;
											}
											else if (tween.tweenType == LeanTweenType.easeShake)
											{
												tween.animationCurve = LeanTween.shake;
											}
											tween.to = tween.from + tween.to;
											tween.diff = tween.to - tween.from;
											if (tweenAction == TweenAction.ROTATE || tweenAction == TweenAction.ROTATE_LOCAL)
											{
												tween.to = new Vector3(closestRot(tween.from.x, tween.to.x), closestRot(tween.from.y, tween.to.y), closestRot(tween.from.z, tween.to.z));
											}
											newVect = tweenOnCurveVector(tween, ratioPassed); break;
										case LeanTweenType.easeSpring:
											newVect = new Vector3(spring(tween.from.x, tween.to.x, ratioPassed), spring(tween.from.y, tween.to.y, ratioPassed), spring(tween.from.z, tween.to.z, ratioPassed)); break;

									}
								}
								else
								{
									newVect = new Vector3(tween.from.x + tween.diff.x * ratioPassed, tween.from.y + tween.diff.y * ratioPassed, tween.from.z + tween.diff.z * ratioPassed);
								}
							}

							if (tweenAction == TweenAction.MOVE)
							{
								trans.position = newVect;
							}
							else if (tweenAction == TweenAction.MOVE_LOCAL)
							{
								trans.localPosition = newVect;
							}
							else if (tweenAction == TweenAction.ROTATE)
							{
								/*if(tween.hasPhysics){
									trans.gameObject.rigidbody.MoveRotation(Quaternion.Euler( newVect ));
								}else{*/
								trans.eulerAngles = newVect;
								// }
							}
							else if (tweenAction == TweenAction.ROTATE_LOCAL)
							{
								trans.localEulerAngles = newVect;
							}
							else if (tweenAction == TweenAction.SCALE)
							{
								trans.localScale = newVect;
							}
							else if (tweenAction == TweenAction.GUI_MOVE)
							{
								tween.ltRect.rect = new Rect(newVect.x, newVect.y, tween.ltRect.rect.width, tween.ltRect.rect.height);
							}
							else if (tweenAction == TweenAction.GUI_MOVE_MARGIN)
							{
								tween.ltRect.margin = new Vector2(newVect.x, newVect.y);
							}
							else if (tweenAction == TweenAction.GUI_SCALE)
							{
								tween.ltRect.rect = new Rect(tween.ltRect.rect.x, tween.ltRect.rect.y, newVect.x, newVect.y);
							}
							else if (tweenAction == TweenAction.GUI_ALPHA)
							{
								tween.ltRect.alpha = newVect.x;
							}
							else if (tweenAction == TweenAction.GUI_ROTATE)
							{
								tween.ltRect.rotation = newVect.x;
							}
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
							else if (tweenAction == TweenAction.CANVAS_MOVE)
							{
								tween.rectTransform.anchoredPosition3D = newVect;
							}
							else if (tweenAction == TweenAction.CANVAS_SCALE)
							{
								tween.rectTransform.localScale = newVect;
							}
#endif
						}
						// Debug.Log("tween.delay:"+tween.delay + " tween.passed:"+tween.passed + " tweenAction:"+tweenAction + " to:"+newVect+" axis:"+tween.axis);

						if (dt != 0f && tween.hasUpdateCallback)
						{
							if (tween.onUpdateFloat != null)
							{
								tween.onUpdateFloat(val);
							}
							if (tween.onUpdateFloatRatio != null)
							{
								tween.onUpdateFloatRatio(val, ratioPassed);
							}
							else if (tween.onUpdateFloatObject != null)
							{
								tween.onUpdateFloatObject(val, tween.onUpdateParam);
							}
							else if (tween.onUpdateVector3Object != null)
							{
								tween.onUpdateVector3Object(newVect, tween.onUpdateParam);
							}
							else if (tween.onUpdateVector3 != null)
							{
								tween.onUpdateVector3(newVect);
							}
							else if (tween.onUpdateVector2 != null)
							{
								tween.onUpdateVector2(new Vector2(newVect.x, newVect.y));
							}
						}
#if LEANTWEEN_1
					else if(tween.optional!=null){ // LeanTween 1.x legacy stuff
						var onUpdate = tween.optional["onUpdate"];
						if(onUpdate!=null){
							Hashtable updateParam = (Hashtable)tween.optional["onUpdateParam"];
							if((TweenAction)tweenAction==TweenAction.VALUE3){
								if(onUpdate.GetType() == typeof(string)){
									string onUpdateS = onUpdate as string;
									customTarget = tween.optional["onUpdateTarget"]!=null ? tween.optional["onUpdateTarget"] as GameObject : trans.gameObject;
									customTarget.BroadcastMessage( onUpdateS, newVect );
								}else if(onUpdate.GetType() == typeof(System.Action<Vector3, Hashtable>)){
									System.Action<Vector3, Hashtable> onUpdateA = (System.Action<Vector3, Hashtable>)onUpdate;
									onUpdateA(newVect, updateParam);
								}else{
									System.Action<Vector3> onUpdateA = (System.Action<Vector3>)onUpdate;
									onUpdateA(newVect);
								}
							}else{
								if(onUpdate.GetType() == typeof(string)){
									string onUpdateS = onUpdate as string;
									if (tween.optional["onUpdateTarget"]!=null){
										customTarget = tween.optional["onUpdateTarget"] as GameObject;
										customTarget.BroadcastMessage( onUpdateS, val );
									}else{
										trans.gameObject.BroadcastMessage( onUpdateS, val );
									}
								}else if(onUpdate.GetType() == typeof(System.Action<float, Hashtable>)){
									System.Action<float, Hashtable> onUpdateA = (System.Action<float, Hashtable>)onUpdate;
									onUpdateA(val, updateParam);
								}else if(onUpdate.GetType() == typeof(System.Action<Vector3>)){
									System.Action<Vector3> onUpdateA = (System.Action<Vector3>)onUpdate;
									onUpdateA( newVect );
								}else{
									System.Action<float> onUpdateA = (System.Action<float>)onUpdate;
									onUpdateA(val);
								}
							}
						}
					}
#endif
					}

					if (isTweenFinished)
					{
						if (tween.loopType == LeanTweenType.once || tween.loopCount == 1)
						{
							tweensFinished[finishedCnt] = i;
							finishedCnt++;

							//Debug.Log("finished tween:"+i+" tween:"+tween);
							if (tweenAction == TweenAction.GUI_ROTATE)
								tween.ltRect.rotateFinished = true;

							if (tweenAction == TweenAction.DELAYED_SOUND)
							{
								AudioSource.PlayClipAtPoint((AudioClip)tween.onCompleteParam, tween.to, tween.from.x);
							}
						}
						else
						{
							if ((tween.loopCount < 0 && tween.type == TweenAction.CALLBACK) || tween.onCompleteOnRepeat)
							{
								if (tweenAction == TweenAction.DELAYED_SOUND)
								{
									AudioSource.PlayClipAtPoint((AudioClip)tween.onCompleteParam, tween.to, tween.from.x);
								}
								if (tween.onComplete != null)
								{
									tween.onComplete();
								}
								else if (tween.onCompleteObject != null)
								{
									tween.onCompleteObject(tween.onCompleteParam);
								}
							}
							if (tween.loopCount >= 1)
							{
								tween.loopCount--;
							}
							// Debug.Log("tween.loopType:"+tween.loopType+" tween.loopCount:"+tween.loopCount+" passed:"+tween.passed);
							if (tween.loopType == LeanTweenType.pingPong)
							{
								tween.direction = 0.0f - (tween.direction);
							}
							else
							{
								tween.passed = Mathf.Epsilon;
							}
						}
					}
					else if (tween.delay <= 0f)
					{
						tween.passed += dt * tween.direction;
					}
					else
					{
						tween.delay -= dt;
						// Debug.Log("dt:"+dt+" tween:"+i+" tween:"+tween);
						if (tween.delay < 0f)
						{
							tween.passed = 0.0f;//-tween.delay
							tween.delay = 0.0f;
						}
					}
				}
			}

			// Debug.Log("maxTweenReached:"+maxTweenReached);
			tweenMaxSearch = maxTweenReached;
			frameRendered = Time.frameCount;

			for (int i = 0; i < finishedCnt; i++)
			{
				j = tweensFinished[i];
				tween = tweens[j];

				// logError("removing tween:"+tween);
				if (tween.onComplete != null)
				{
					System.Action onComplete = tween.onComplete;
					//logError("removing tween for j:"+j+" tween:"+tween);
					removeTween(j);
					//tween.cleanup();
					onComplete();

				}
				else if (tween.onCompleteObject != null)
				{
					System.Action<object> onCompleteObject = tween.onCompleteObject;
					object onCompleteParam = tween.onCompleteParam;
					removeTween(j);
					//tween.cleanup();
					onCompleteObject(onCompleteParam);
				}
#if LEANTWEEN_1
			else if(tween.optional!=null){
				System.Action callback=null;
				System.Action<object> callbackWithParam = null;
				string callbackS=string.Empty;
				object callbackParam=null;
				Hashtable optional = tween.optional;
				if(tween.optional!=null && tween.trans){
					if(tween.optional["onComplete"]!=null){
						callbackParam = tween.optional["onCompleteParam"];
						if(tween.optional["onComplete"].GetType()==typeof(string)){
							callbackS = tween.optional["onComplete"] as string;
						}else{
							if(callbackParam!=null){
								callbackWithParam = (System.Action<object>)tween.optional["onComplete"];
							}else{
								callback = (System.Action)tween.optional["onComplete"];	
								if(callback==null)
									Debug.LogWarning("callback was not converted");
							}
						}
					}
				}
				removeTween(j);
				if(callbackWithParam!=null){
					callbackWithParam( callbackParam );
				}else if(callback!=null){
					callback();
				}else if(callbackS!=string.Empty){
					if (optional["onCompleteTarget"]!=null){
						customTarget = optional["onCompleteTarget"] as GameObject;
						if(callbackParam!=null) customTarget.BroadcastMessage ( callbackS, callbackParam );
						else customTarget.BroadcastMessage( callbackS );
					}else{
						if(callbackParam!=null) trans.gameObject.BroadcastMessage ( callbackS, callbackParam );
						else trans.gameObject.BroadcastMessage( callbackS );
					}
				}
				
			}
#endif
				else
				{
					removeTween(j);
					//tween.cleanup();
				}
			}

		}
	}