Jam
/
GGJ_2020
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
32 Commits
1 Branch
407 KiB
 
 
 
 
Tree: d7d7c7bfcd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd7d7c7bfcd'
${ noResults }
GGJ_2020/Assets/Plugins/LeanTween/LTDescr.cs

2285 lines
79 KiB
Raw Blame History

//namespace DentedPixel{
using System;
using UnityEngine;
/**
* Internal Representation of a Tween<br>
* <br>
* This class represents all of the optional parameters you can pass to a method (it also represents the internal representation of the tween).<br><br>
* <strong id='optional'>Optional Parameters</strong> are passed at the end of every method:<br>
* <br>
* &nbsp;&nbsp;<i>Example:</i><br>
* &nbsp;&nbsp;LeanTween.moveX( gameObject, 1f, 1f).setEase( <a href="LeanTweenType.html">LeanTweenType</a>.easeInQuad ).setDelay(1f);<br>
* <br>
* You can pass the optional parameters in any order, and chain on as many as you wish.<br>
* You can also <strong>pass parameters at a later time</strong> by saving a reference to what is returned.<br>
* <br>
* Retrieve a <strong>unique id</strong> for the tween by using the "id" property. You can pass this to LeanTween.pause, LeanTween.resume, LeanTween.cancel, LeanTween.isTweening methods<br>
* <br>
* &nbsp;&nbsp;<h4>Example:</h4>
* &nbsp;&nbsp;int id = LeanTween.moveX(gameObject, 1f, 3f).id;<br>
* <div style="color:gray">&nbsp;&nbsp;// pause a specific tween</div>
* &nbsp;&nbsp;LeanTween.pause(id);<br>
* <div style="color:gray">&nbsp;&nbsp;// resume later</div>
* &nbsp;&nbsp;LeanTween.resume(id);<br>
* <div style="color:gray">&nbsp;&nbsp;// check if it is tweening before kicking of a new tween</div>
* &nbsp;&nbsp;if( LeanTween.isTweening( id ) ){<br>
* &nbsp;&nbsp; &nbsp;&nbsp; LeanTween.cancel( id );<br>
* &nbsp;&nbsp; &nbsp;&nbsp; LeanTween.moveZ(gameObject, 10f, 3f);<br>
* &nbsp;&nbsp;}<br>
* @class LTDescr
* @constructor
*/
public class LTDescr
{
public bool toggle;
public bool useEstimatedTime;
public bool useFrames;
public bool useManualTime;
public bool usesNormalDt;
public bool hasInitiliazed;
public bool hasExtraOnCompletes;
public bool hasPhysics;
public bool onCompleteOnRepeat;
public bool onCompleteOnStart;
public bool useRecursion;
public float ratioPassed;
public float passed;
public float delay;
public float time;
public float speed;
public float lastVal;
private uint _id;
public int loopCount;
public uint counter = uint.MaxValue;
public float direction;
public float directionLast;
public float overshoot;
public float period;
public float scale;
public bool destroyOnComplete;
public Transform trans;
internal Vector3 fromInternal;
public Vector3 from { get { return this.fromInternal; } set { this.fromInternal = value; } }
internal Vector3 toInternal;
public Vector3 to { get { return this.toInternal; } set { this.toInternal = value; } }
internal Vector3 diff;
internal Vector3 diffDiv2;
public TweenAction type;
private LeanTweenType easeType;
public LeanTweenType loopType;
public bool hasUpdateCallback;
public EaseTypeDelegate easeMethod;
public ActionMethodDelegate easeInternal {get; set; }
public ActionMethodDelegate initInternal {get; set; }
public delegate Vector3 EaseTypeDelegate();
public delegate void ActionMethodDelegate();
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
public SpriteRenderer spriteRen;
#endif
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
public RectTransform rectTransform;
public UnityEngine.UI.Text uiText;
public UnityEngine.UI.Image uiImage;
public UnityEngine.UI.RawImage rawImage;
public UnityEngine.Sprite[] sprites;
#endif
public LTDescrOptional _optional = new LTDescrOptional();
public override string ToString(){
return (trans!=null ? "name:"+trans.gameObject.name : "gameObject:null")+" toggle:"+toggle+" passed:"+passed+" time:"+time+" delay:"+delay+" direction:"+direction+" from:"+from+" to:"+to+" diff:"+diff+" type:"+type+" ease:"+easeType+" useEstimatedTime:"+useEstimatedTime+" id:"+id+" hasInitiliazed:"+hasInitiliazed;
}
public LTDescr(){
}
[System.Obsolete("Use 'LeanTween.cancel( id )' instead")]
public LTDescr cancel( GameObject gameObject ){
// Debug.Log("canceling id:"+this._id+" this.uniqueId:"+this.uniqueId+" go:"+this.trans.gameObject);
if(gameObject==this.trans.gameObject)
LeanTween.removeTween((int)this._id, this.uniqueId);
return this;
}
public int uniqueId{
get{
uint toId = _id | counter << 16;
/*uint backId = toId & 0xFFFF;
uint backCounter = toId >> 16;
if(_id!=backId || backCounter!=counter){
Debug.LogError("BAD CONVERSION toId:"+_id);
}*/
return (int)toId;
}
}
public int id{
get{
return uniqueId;
}
}
public LTDescrOptional optional{
get{
return _optional;
}
set{
this._optional = optional;
}
}
public void reset(){
this.toggle = this.useRecursion = this.usesNormalDt = true;
this.trans = null;
this.spriteRen = null;
this.passed = this.delay = this.lastVal = 0.0f;
this.hasUpdateCallback = this.useEstimatedTime = this.useFrames = this.hasInitiliazed = this.onCompleteOnRepeat = this.destroyOnComplete = this.onCompleteOnStart = this.useManualTime = this.hasExtraOnCompletes = false;
this.easeType = LeanTweenType.linear;
this.loopType = LeanTweenType.once;
this.loopCount = 0;
this.direction = this.directionLast = this.overshoot = this.scale = 1.0f;
this.period = 0.3f;
this.speed = -1f;
this.easeMethod = this.easeLinear;
this.from = this.to = Vector3.zero;
this._optional.reset();
}
// Initialize and Internal Methods
public LTDescr setMoveX(){
this.type = TweenAction.MOVE_X;
this.initInternal = ()=>{ this.fromInternal.x = trans.position.x; };
this.easeInternal = ()=>{ trans.position=new Vector3( easeMethod().x,trans.position.y,trans.position.z); };
return this;
}
public LTDescr setMoveY(){
this.type = TweenAction.MOVE_Y;
this.initInternal = ()=>{ this.fromInternal.x = trans.position.y; };
this.easeInternal = ()=>{ trans.position=new Vector3( trans.position.x,easeMethod().x,trans.position.z); };
return this;
}
public LTDescr setMoveZ(){
this.type = TweenAction.MOVE_Z;
this.initInternal = ()=>{ this.fromInternal.x = trans.position.z; };;
this.easeInternal = ()=>{ trans.position=new Vector3( trans.position.x,trans.position.y,easeMethod().x); };
return this;
}
public LTDescr setMoveLocalX(){
this.type = TweenAction.MOVE_LOCAL_X;
this.initInternal = ()=>{ this.fromInternal.x = trans.localPosition.x; };
this.easeInternal = ()=>{ trans.localPosition=new Vector3( easeMethod().x,trans.localPosition.y,trans.localPosition.z); };
return this;
}
public LTDescr setMoveLocalY(){
this.type = TweenAction.MOVE_LOCAL_Y;
this.initInternal = ()=>{ this.fromInternal.x = trans.localPosition.y; };
this.easeInternal = ()=>{ trans.localPosition=new Vector3( trans.localPosition.x,easeMethod().x,trans.localPosition.z); };
return this;
}
public LTDescr setMoveLocalZ(){
this.type = TweenAction.MOVE_LOCAL_Z;
this.initInternal = ()=>{ this.fromInternal.x = trans.localPosition.z; };
this.easeInternal = ()=>{ trans.localPosition=new Vector3( trans.localPosition.x,trans.localPosition.y,easeMethod().x); };
return this;
}
private void initFromInternal(){ this.fromInternal.x = 0; }
public LTDescr setMoveCurved(){
this.type = TweenAction.MOVE_CURVED;
this.initInternal = this.initFromInternal;
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
if(this._optional.path.orientToPath){
if(this._optional.path.orientToPath2d){
this._optional.path.place2d( trans, val );
}else{
this._optional.path.place( trans, val );
}
}else{
trans.position = this._optional.path.point( val );
}
};
return this;
}
public LTDescr setMoveCurvedLocal(){
this.type = TweenAction.MOVE_CURVED_LOCAL;
this.initInternal = this.initFromInternal;
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
if(this._optional.path.orientToPath){
if(this._optional.path.orientToPath2d){
this._optional.path.placeLocal2d( trans, val );
}else{
this._optional.path.placeLocal( trans, val );
}
}else{
trans.localPosition = this._optional.path.point( val );
}
};
return this;
}
public LTDescr setMoveSpline(){
this.type = TweenAction.MOVE_SPLINE;
this.initInternal = this.initFromInternal;
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
if(this._optional.spline.orientToPath){
if(this._optional.spline.orientToPath2d){
this._optional.spline.place2d( trans, val );
}else{
this._optional.spline.place( trans, val );
}
}else{
trans.position = this._optional.spline.point( val );
}
};
return this;
}
public LTDescr setMoveSplineLocal(){
this.type = TweenAction.MOVE_SPLINE_LOCAL;
this.initInternal = this.initFromInternal;
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
if(this._optional.spline.orientToPath){
if(this._optional.spline.orientToPath2d){
this._optional.spline.placeLocal2d( trans, val );
}else{
this._optional.spline.placeLocal( trans, val );
}
}else{
trans.localPosition = this._optional.spline.point( val );
}
};
return this;
}
public LTDescr setScaleX(){
this.type = TweenAction.SCALE_X;
this.initInternal = ()=>{ this.fromInternal.x = trans.localScale.x; };
this.easeInternal = ()=>{ trans.localScale = new Vector3( easeMethod().x,trans.localScale.y,trans.localScale.z); };
return this;
}
public LTDescr setScaleY(){
this.type = TweenAction.SCALE_Y;
this.initInternal = ()=>{ this.fromInternal.x = trans.localScale.y; };
this.easeInternal = ()=>{ trans.localScale=new Vector3( trans.localScale.x,easeMethod().x,trans.localScale.z); };
return this;
}
public LTDescr setScaleZ(){
this.type = TweenAction.SCALE_Z;
this.initInternal = ()=>{ this.fromInternal.x = trans.localScale.z; };
this.easeInternal = ()=>{ trans.localScale=new Vector3( trans.localScale.x,trans.localScale.y,easeMethod().x); };
return this;
}
public LTDescr setRotateX(){
this.type = TweenAction.ROTATE_X;
this.initInternal = ()=>{ this.fromInternal.x = trans.eulerAngles.x; this.toInternal.x = LeanTween.closestRot( this.fromInternal.x, this.toInternal.x);};
this.easeInternal = ()=>{ trans.eulerAngles=new Vector3(easeMethod().x,trans.eulerAngles.y,trans.eulerAngles.z); };
return this;
}
public LTDescr setRotateY(){
this.type = TweenAction.ROTATE_Y;
this.initInternal = ()=>{ this.fromInternal.x = trans.eulerAngles.y; this.toInternal.x = LeanTween.closestRot( this.fromInternal.x, this.toInternal.x);};
this.easeInternal = ()=>{ trans.eulerAngles=new Vector3(trans.eulerAngles.x,easeMethod().x,trans.eulerAngles.z); };
return this;
}
public LTDescr setRotateZ(){
this.type = TweenAction.ROTATE_Z;
this.initInternal = ()=>{
this.fromInternal.x = trans.eulerAngles.z;
this.toInternal.x = LeanTween.closestRot( this.fromInternal.x, this.toInternal.x);
};
this.easeInternal = ()=>{ trans.eulerAngles=new Vector3(trans.eulerAngles.x,trans.eulerAngles.y,easeMethod().x); };
return this;
}
public LTDescr setRotateAround(){
this.type = TweenAction.ROTATE_AROUND;
this.initInternal = ()=>{
this.fromInternal.x = 0f;
this._optional.origRotation = trans.rotation;
};
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
Vector3 origPos = trans.localPosition;
Vector3 rotateAroundPt = (Vector3)trans.TransformPoint( this._optional.point );
// Debug.Log("this._optional.point:"+this._optional.point);
trans.RotateAround(rotateAroundPt, this._optional.axis, -this._optional.lastVal);
Vector3 diff = origPos - trans.localPosition;
trans.localPosition = origPos - diff; // Subtract the amount the object has been shifted over by the rotate, to get it back to it's orginal position
trans.rotation = this._optional.origRotation;
rotateAroundPt = (Vector3)trans.TransformPoint( this._optional.point );
trans.RotateAround(rotateAroundPt, this._optional.axis, val);
this._optional.lastVal = val;
};
return this;
}
public LTDescr setRotateAroundLocal(){
this.type = TweenAction.ROTATE_AROUND_LOCAL;
this.initInternal = ()=>{
this.fromInternal.x = 0f;
this._optional.origRotation = trans.localRotation;
};
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
Vector3 origPos = trans.localPosition;
trans.RotateAround((Vector3)trans.TransformPoint( this._optional.point ), trans.TransformDirection(this._optional.axis), -this._optional.lastVal);
Vector3 diff = origPos - trans.localPosition;
trans.localPosition = origPos - diff; // Subtract the amount the object has been shifted over by the rotate, to get it back to it's orginal position
trans.localRotation = this._optional.origRotation;
Vector3 rotateAroundPt = (Vector3)trans.TransformPoint( this._optional.point );
trans.RotateAround(rotateAroundPt, trans.TransformDirection(this._optional.axis), val);
this._optional.lastVal = val;
};
return this;
}
public LTDescr setAlpha(){
this.type = TweenAction.ALPHA;
this.initInternal = ()=>{
#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
if(trans.gameObject.renderer){ this.fromInternal.x = trans.gameObject.renderer.material.color.a; }else if(trans.childCount>0){ foreach (Transform child in trans) { if(child.gameObject.renderer!=null){ Color col = child.gameObject.renderer.material.color; this.fromInternal.x = col.a; break; }}}
this.easeInternal = this.alpha;
break;
#else
SpriteRenderer ren = trans.GetComponent<SpriteRenderer>();
if(ren!=null){
this.fromInternal.x = ren.color.a;
}else{
if(trans.GetComponent<Renderer>()!=null && trans.GetComponent<Renderer>().material.HasProperty("_Color")){
this.fromInternal.x = trans.GetComponent<Renderer>().material.color.a;
}else if(trans.GetComponent<Renderer>()!=null && trans.GetComponent<Renderer>().material.HasProperty("_TintColor")){
Color col = trans.GetComponent<Renderer>().material.GetColor("_TintColor");
this.fromInternal.x = col.a;
}else if(trans.childCount>0){
foreach (Transform child in trans) {
if(child.gameObject.GetComponent<Renderer>()!=null){
Color col = child.gameObject.GetComponent<Renderer>().material.color;
this.fromInternal.x = col.a;
break;
}
}
}
}
#endif
this.easeInternal = ()=>{
val = easeMethod().x;
#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
alphaRecursive(this.trans, val, this.useRecursion);
#else
if(this.spriteRen!=null){
this.spriteRen.color = new Color( this.spriteRen.color.r, this.spriteRen.color.g, this.spriteRen.color.b, val);
alphaRecursiveSprite(this.trans, val);
}else{
alphaRecursive(this.trans, val, this.useRecursion);
}
#endif
};
};
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
alphaRecursive(this.trans, val, this.useRecursion);
#else
if(this.spriteRen!=null){
this.spriteRen.color = new Color( this.spriteRen.color.r, this.spriteRen.color.g, this.spriteRen.color.b, val);
alphaRecursiveSprite(this.trans, val);
}else{
alphaRecursive(this.trans, val, this.useRecursion);
}
#endif
};
return this;
}
public LTDescr setTextAlpha(){
this.type = TweenAction.TEXT_ALPHA;
this.initInternal = ()=>{
this.uiText = trans.GetComponent<UnityEngine.UI.Text>();
this.fromInternal.x = this.uiText != null ? this.uiText.color.a : 1f;
};
this.easeInternal = ()=>{ textAlphaRecursive( trans, easeMethod().x, this.useRecursion ); };
return this;
}
public LTDescr setAlphaVertex(){
this.type = TweenAction.ALPHA_VERTEX;
this.initInternal = ()=>{ this.fromInternal.x = trans.GetComponent<MeshFilter>().mesh.colors32[0].a; };
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
Mesh mesh = trans.GetComponent<MeshFilter>().mesh;
Vector3[] vertices = mesh.vertices;
Color32[] colors = new Color32[vertices.Length];
if (colors.Length == 0){ //MaxFW fix: add vertex colors if the mesh doesn't have any
Color32 transparentWhiteColor32 = new Color32(0xff, 0xff, 0xff, 0x00);
colors = new Color32[mesh.vertices.Length];
for (int k=0; k<colors.Length; k++)
colors[k] = transparentWhiteColor32;
mesh.colors32 = colors;
}// fix end
Color32 c = mesh.colors32[0];
c = new Color( c.r, c.g, c.b, val);
for (int k= 0; k < vertices.Length; k++)
colors[k] = c;
mesh.colors32 = colors;
};
return this;
}
public LTDescr setColor(){
this.type = TweenAction.COLOR;
this.initInternal = ()=>{
#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
if(trans.gameObject.renderer){
this.setFromColor( trans.gameObject.renderer.material.color );
}else if(trans.childCount>0){
foreach (Transform child in trans) {
if(child.gameObject.renderer!=null){
this.setFromColor( child.gameObject.renderer.material.color );
break;
}
}
}
#else
SpriteRenderer renColor = trans.GetComponent<SpriteRenderer>();
if(renColor!=null){
this.setFromColor( renColor.color );
}else{
if(trans.GetComponent<Renderer>()!=null && trans.GetComponent<Renderer>().material.HasProperty("_Color")){
Color col = trans.GetComponent<Renderer>().material.color;
this.setFromColor( col );
}else if(trans.GetComponent<Renderer>()!=null && trans.GetComponent<Renderer>().material.HasProperty("_TintColor")){
Color col = trans.GetComponent<Renderer>().material.GetColor ("_TintColor");
this.setFromColor( col );
}else if(trans.childCount>0){
foreach (Transform child in trans) {
if(child.gameObject.GetComponent<Renderer>()!=null){
Color col = child.gameObject.GetComponent<Renderer>().material.color;
this.setFromColor( col );
break;
}
}
}
}
#endif
};
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
Color toColor = tweenColor(this, val);
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
if(this.spriteRen!=null){
this.spriteRen.color = toColor;
colorRecursiveSprite( trans, toColor);
}else{
#endif
// Debug.Log("val:"+val+" tween:"+tween+" tween.diff:"+tween.diff);
if(this.type==TweenAction.COLOR)
colorRecursive(trans, toColor, this.useRecursion);
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
}
#endif
if(dt!=0f && this._optional.onUpdateColor!=null){
this._optional.onUpdateColor(toColor);
}else if(dt!=0f && this._optional.onUpdateColorObject!=null){
this._optional.onUpdateColorObject(toColor, this._optional.onUpdateParam);
}
};
return this;
}
public LTDescr setCallbackColor(){
this.type = TweenAction.CALLBACK_COLOR;
this.initInternal = ()=>{ this.diff = new Vector3(1.0f,0.0f,0.0f); };
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
Color toColor = tweenColor(this, val);
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
if(this.spriteRen!=null){
this.spriteRen.color = toColor;
colorRecursiveSprite( trans, toColor);
}else{
#endif
// Debug.Log("val:"+val+" tween:"+tween+" tween.diff:"+tween.diff);
if(this.type==TweenAction.COLOR)
colorRecursive(trans, toColor, this.useRecursion);
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
}
#endif
if(dt!=0f && this._optional.onUpdateColor!=null){
this._optional.onUpdateColor(toColor);
}else if(dt!=0f && this._optional.onUpdateColorObject!=null){
this._optional.onUpdateColorObject(toColor, this._optional.onUpdateParam);
}
};
return this;
}
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
public LTDescr setTextColor(){
this.type = TweenAction.TEXT_COLOR;
this.initInternal = ()=>{
this.uiText = trans.GetComponent<UnityEngine.UI.Text>();
this.setFromColor( this.uiText != null ? this.uiText.color : Color.white );
};
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
Color toColor = tweenColor(this, val);
this.uiText.color = toColor;
if (dt!=0f && this._optional.onUpdateColor != null)
this._optional.onUpdateColor(toColor);
if(this.useRecursion && trans.childCount>0)
textColorRecursive(this.trans, toColor);
};
return this;
}
public LTDescr setCanvasAlpha(){
this.type = TweenAction.CANVAS_ALPHA;
this.initInternal = ()=>{
this.uiImage = trans.GetComponent<UnityEngine.UI.Image>();
if(this.uiImage!=null){
this.fromInternal.x = this.uiImage.color.a;
}else{
this.rawImage = trans.GetComponent<UnityEngine.UI.RawImage>();
if(this.rawImage != null){
this.fromInternal.x = this.rawImage.color.a;
}else{
this.fromInternal.x = 1f;
}
}
};
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
if(this.uiImage!=null){
Color c = this.uiImage.color; c.a = val; this.uiImage.color = c;
}else if(this.rawImage!=null){
Color c = this.rawImage.color; c.a = val; this.rawImage.color = c;
}
if(this.useRecursion){
alphaRecursive( this.rectTransform, val, 0 );
textAlphaChildrenRecursive( this.rectTransform, val);
}
};
return this;
}
public LTDescr setCanvasGroupAlpha(){
this.type = TweenAction.CANVASGROUP_ALPHA;
this.initInternal = ()=>{this.fromInternal.x = trans.GetComponent<CanvasGroup>().alpha;};
this.easeInternal = ()=>{ this.trans.GetComponent<CanvasGroup>().alpha = easeMethod().x; };
return this;
}
public LTDescr setCanvasColor(){
this.type = TweenAction.CANVAS_COLOR;
this.initInternal = ()=>{
this.uiImage = trans.GetComponent<UnityEngine.UI.Image>();
if(this.uiImage==null){
this.rawImage = trans.GetComponent<UnityEngine.UI.RawImage>();
this.setFromColor( this.rawImage!=null ? this.rawImage.color : Color.white );
}else{
this.setFromColor( this.uiImage.color );
}
};
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
Color toColor = tweenColor(this, val);
if(this.uiImage!=null){
this.uiImage.color = toColor;
}else if(this.rawImage!=null){
this.rawImage.color = toColor;
}
if (dt!=0f && this._optional.onUpdateColor != null)
this._optional.onUpdateColor(toColor);
if(this.useRecursion)
colorRecursive(this.rectTransform, toColor);
};
return this;
}
public LTDescr setCanvasMoveX(){
this.type = TweenAction.CANVAS_MOVE_X;
this.initInternal = ()=>{ this.fromInternal.x = this.rectTransform.anchoredPosition3D.x; };
this.easeInternal = ()=>{ Vector3 c = this.rectTransform.anchoredPosition3D; this.rectTransform.anchoredPosition3D = new Vector3(easeMethod().x, c.y, c.z); };
return this;
}
public LTDescr setCanvasMoveY(){
this.type = TweenAction.CANVAS_MOVE_Y;
this.initInternal = ()=>{ this.fromInternal.x = this.rectTransform.anchoredPosition3D.y; };
this.easeInternal = ()=>{ Vector3 c = this.rectTransform.anchoredPosition3D; this.rectTransform.anchoredPosition3D = new Vector3(c.x, easeMethod().x, c.z); };
return this;
}
public LTDescr setCanvasMoveZ(){
this.type = TweenAction.CANVAS_MOVE_Z;
this.initInternal = ()=>{ this.fromInternal.x = this.rectTransform.anchoredPosition3D.z; };
this.easeInternal = ()=>{ Vector3 c = this.rectTransform.anchoredPosition3D; this.rectTransform.anchoredPosition3D = new Vector3(c.x, c.y, easeMethod().x); };
return this;
}
private void initCanvasRotateAround(){
this.lastVal = 0.0f;
this.fromInternal.x = 0.0f;
this._optional.origRotation = this.rectTransform.rotation;
}
public LTDescr setCanvasRotateAround(){
this.type = TweenAction.CANVAS_ROTATEAROUND;
this.initInternal = this.initCanvasRotateAround;
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
RectTransform rect = this.rectTransform;
Vector3 origPos = rect.localPosition;
rect.RotateAround((Vector3)rect.TransformPoint( this._optional.point ), this._optional.axis, -val);
Vector3 diff = origPos - rect.localPosition;
rect.localPosition = origPos - diff; // Subtract the amount the object has been shifted over by the rotate, to get it back to it's orginal position
rect.rotation = this._optional.origRotation;
rect.RotateAround((Vector3)rect.TransformPoint( this._optional.point ), this._optional.axis, val);
};
return this;
}
public LTDescr setCanvasRotateAroundLocal(){
this.type = TweenAction.CANVAS_ROTATEAROUND_LOCAL;
this.initInternal = this.initCanvasRotateAround;
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
RectTransform rect = this.rectTransform;
Vector3 origPos = rect.localPosition;
rect.RotateAround((Vector3)rect.TransformPoint( this._optional.point ), rect.TransformDirection(this._optional.axis), -val);
Vector3 diff = origPos - rect.localPosition;
rect.localPosition = origPos - diff; // Subtract the amount the object has been shifted over by the rotate, to get it back to it's orginal position
rect.rotation = this._optional.origRotation;
rect.RotateAround((Vector3)rect.TransformPoint( this._optional.point ), rect.TransformDirection(this._optional.axis), val);
};
return this;
}
public LTDescr setCanvasPlaySprite(){
this.type = TweenAction.CANVAS_PLAYSPRITE;
this.initInternal = ()=>{
this.uiImage = trans.GetComponent<UnityEngine.UI.Image>();
this.fromInternal.x = 0f;
};
this.easeInternal = ()=>{
newVect = easeMethod();
val = newVect.x;
int frame = (int)Mathf.Round( val );
this.uiImage.sprite = this.sprites[ frame ];
};
return this;
}
public LTDescr setCanvasMove(){
this.type = TweenAction.CANVAS_MOVE;
this.initInternal = ()=>{ this.fromInternal = this.rectTransform.anchoredPosition3D; };
this.easeInternal = ()=>{ this.rectTransform.anchoredPosition3D = easeMethod(); };
return this;
}
public LTDescr setCanvasScale(){
this.type = TweenAction.CANVAS_SCALE;
this.initInternal = ()=>{ this.from = this.rectTransform.localScale; };
this.easeInternal = ()=>{ this.rectTransform.localScale = easeMethod(); };
return this;
}
public LTDescr setCanvasSizeDelta(){
this.type = TweenAction.CANVAS_SIZEDELTA;
this.initInternal = ()=>{ this.from = this.rectTransform.sizeDelta; };
this.easeInternal = ()=>{ this.rectTransform.sizeDelta = easeMethod(); };
return this;
}
#endif
private void callback(){ newVect = easeMethod(); val = newVect.x; }
public LTDescr setCallback(){
this.type = TweenAction.CALLBACK;
this.initInternal = ()=>{};
this.easeInternal = this.callback;
return this;
}
public LTDescr setValue3(){
this.type = TweenAction.VALUE3;
this.initInternal = ()=>{};
this.easeInternal = this.callback;
return this;
}
public LTDescr setMove(){
this.type = TweenAction.MOVE;
this.initInternal = ()=>{ this.from = trans.position; };
this.easeInternal = ()=>{
newVect = easeMethod();
trans.position = newVect;
};
return this;
}
public LTDescr setMoveLocal(){
this.type = TweenAction.MOVE_LOCAL;
this.initInternal = ()=>{ this.from = trans.localPosition; };
this.easeInternal = ()=>{
newVect = easeMethod();
trans.localPosition = newVect;
};
return this;
}
public LTDescr setMoveToTransform(){
this.type = TweenAction.MOVE_TO_TRANSFORM;
this.initInternal = ()=>{ this.from = trans.position; };
this.easeInternal = ()=>{
this.to = this._optional.toTrans.position;
this.diff = this.to - this.from;
this.diffDiv2 = this.diff * 0.5f;
newVect = easeMethod();
this.trans.position = newVect;
};
return this;
}
public LTDescr setRotate(){
this.type = TweenAction.ROTATE;
this.initInternal = ()=>{ this.from = trans.eulerAngles; this.to = new Vector3(LeanTween.closestRot( this.fromInternal.x, this.toInternal.x), LeanTween.closestRot( this.from.y, this.to.y), LeanTween.closestRot( this.from.z, this.to.z)); };
this.easeInternal = ()=>{
newVect = easeMethod();
trans.eulerAngles = newVect;
};
return this;
}
public LTDescr setRotateLocal(){
this.type = TweenAction.ROTATE_LOCAL;
this.initInternal = ()=>{ this.from = trans.localEulerAngles; this.to = new Vector3(LeanTween.closestRot( this.fromInternal.x, this.toInternal.x), LeanTween.closestRot( this.from.y, this.to.y), LeanTween.closestRot( this.from.z, this.to.z)); };
this.easeInternal = ()=>{
newVect = easeMethod();
trans.localEulerAngles = newVect;
};
return this;
}
public LTDescr setScale(){
this.type = TweenAction.SCALE;
this.initInternal = ()=>{ this.from = trans.localScale; };
this.easeInternal = ()=>{
newVect = easeMethod();
trans.localScale = newVect;
};
return this;
}
public LTDescr setGUIMove(){
this.type = TweenAction.GUI_MOVE;
this.initInternal = ()=>{ this.from = new Vector3(this._optional.ltRect.rect.x, this._optional.ltRect.rect.y, 0); };
this.easeInternal = ()=>{ Vector3 v = easeMethod(); this._optional.ltRect.rect = new Rect( v.x, v.y, this._optional.ltRect.rect.width, this._optional.ltRect.rect.height); };
return this;
}
public LTDescr setGUIMoveMargin(){
this.type = TweenAction.GUI_MOVE_MARGIN;
this.initInternal = ()=>{ this.from = new Vector2(this._optional.ltRect.margin.x, this._optional.ltRect.margin.y); };
this.easeInternal = ()=>{ Vector3 v = easeMethod(); this._optional.ltRect.margin = new Vector2(v.x, v.y); };
return this;
}
public LTDescr setGUIScale(){
this.type = TweenAction.GUI_SCALE;
this.initInternal = ()=>{ this.from = new Vector3(this._optional.ltRect.rect.width, this._optional.ltRect.rect.height, 0); };
this.easeInternal = ()=>{ Vector3 v = easeMethod(); this._optional.ltRect.rect = new Rect( this._optional.ltRect.rect.x, this._optional.ltRect.rect.y, v.x, v.y); };
return this;
}
public LTDescr setGUIAlpha(){
this.type = TweenAction.GUI_ALPHA;
this.initInternal = ()=>{ this.fromInternal.x = this._optional.ltRect.alpha; };
this.easeInternal = ()=>{ this._optional.ltRect.alpha = easeMethod().x; };
return this;
}
public LTDescr setGUIRotate(){
this.type = TweenAction.GUI_ROTATE;
this.initInternal = ()=>{ if(this._optional.ltRect.rotateEnabled==false){
this._optional.ltRect.rotateEnabled = true;
this._optional.ltRect.resetForRotation();
}
this.fromInternal.x = this._optional.ltRect.rotation;
};
this.easeInternal = ()=>{ this._optional.ltRect.rotation = easeMethod().x; };
return this;
}
public LTDescr setDelayedSound(){
this.type = TweenAction.DELAYED_SOUND;
this.initInternal = ()=>{ this.hasExtraOnCompletes = true; };
this.easeInternal = this.callback;
return this;
}
private void init(){
this.hasInitiliazed = true;
usesNormalDt = !(useEstimatedTime || useManualTime || useFrames); // only set this to true if it uses non of the other timing modes
if (useFrames)
this.optional.initFrameCount = Time.frameCount;
if (this.time <= 0f) // avoid dividing by zero
this.time = Mathf.Epsilon;
this.initInternal();
this.diff = this.to - this.from;
this.diffDiv2 = this.diff * 0.5f;
if (this._optional.onStart != null)
this._optional.onStart();
if(this.onCompleteOnStart)
callOnCompletes();
if(this.speed>=0){
initSpeed();
}
}
private void initSpeed(){
if(this.type==TweenAction.MOVE_CURVED || this.type==TweenAction.MOVE_CURVED_LOCAL){
this.time = this._optional.path.distance / this.speed;
}else if(this.type==TweenAction.MOVE_SPLINE || this.type==TweenAction.MOVE_SPLINE_LOCAL){
this.time = this._optional.spline.distance/ this.speed;
}else{
this.time = (this.to - this.from).magnitude / this.speed;
}
}
public static float val;
public static float dt;
public static Vector3 newVect;
/**
* If you need a tween to happen immediately instead of waiting for the next Update call, you can force it with this method
*
* @method updateNow
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 0f ).updateNow();
*/
public LTDescr updateNow(){
updateInternal();
return this;
}
public bool updateInternal(){
float directionLocal = this.direction;
if(this.usesNormalDt){
dt = LeanTween.dtActual;
}else if( this.useEstimatedTime ){
dt = LeanTween.dtEstimated;
}else if( this.useFrames ){
dt = this.optional.initFrameCount==0 ? 0 : 1;
this.optional.initFrameCount = Time.frameCount;
}else if( this.useManualTime ){
dt = LeanTween.dtManual;
}
// Debug.Log ("tween:" + this+ " dt:"+dt);
if(this.delay<=0f && directionLocal!=0f){
if(trans==null)
return true;
// initialize if has not done so yet
if(!this.hasInitiliazed)
this.init();
dt = dt*directionLocal;
this.passed += dt;
this.passed = Mathf.Clamp(this.passed, 0f, this.time);
this.ratioPassed = (this.passed / this.time); // need to clamp when finished so it will finish at the exact spot and not overshoot
this.easeInternal();
if(this.hasUpdateCallback)
this._optional.callOnUpdate(val, this.ratioPassed);
bool isTweenFinished = directionLocal>0f ? this.passed>=this.time : this.passed<=0f;
// Debug.Log("lt "+this+" dt:"+dt+" fin:"+isTweenFinished);
if(isTweenFinished){ // increment or flip tween
this.loopCount--;
if(this.loopType==LeanTweenType.pingPong){
this.direction = 0.0f-directionLocal;
}else{
this.passed = Mathf.Epsilon;
}
isTweenFinished = this.loopCount == 0 || this.loopType == LeanTweenType.once; // only return true if it is fully complete
if(isTweenFinished==false && this.onCompleteOnRepeat && this.hasExtraOnCompletes)
callOnCompletes(); // this only gets called if onCompleteOnRepeat is set to true, otherwise LeanTween class takes care of calling it
return isTweenFinished;
}
}else{
this.delay -= dt;
}
return false;
}
public void callOnCompletes(){
if(this.type==TweenAction.GUI_ROTATE)
this._optional.ltRect.rotateFinished = true;
if(this.type==TweenAction.DELAYED_SOUND){
AudioSource.PlayClipAtPoint((AudioClip)this._optional.onCompleteParam, this.to, this.from.x);
}
if(this._optional.onComplete!=null){
this._optional.onComplete();
}else if(this._optional.onCompleteObject!=null){
this._optional.onCompleteObject(this._optional.onCompleteParam);
}
}
// Helper Methods
public LTDescr setFromColor( Color col ){
this.from = new Vector3(0.0f, col.a, 0.0f);
this.diff = new Vector3(1.0f,0.0f,0.0f);
this._optional.axis = new Vector3( col.r, col.g, col.b );
return this;
}
private static void alphaRecursive( Transform transform, float val, bool useRecursion = true){
Renderer renderer = transform.gameObject.GetComponent<Renderer>();
if(renderer!=null){
foreach(Material mat in renderer.materials){
if(mat.HasProperty("_Color")){
mat.color = new Color( mat.color.r, mat.color.g, mat.color.b, val);
}else if(mat.HasProperty("_TintColor")){
Color col = mat.GetColor ("_TintColor");
mat.SetColor("_TintColor", new Color( col.r, col.g, col.b, val));
}
}
}
if(useRecursion && transform.childCount>0){
foreach (Transform child in transform) {
alphaRecursive(child, val);
}
}
}
private static void colorRecursive( Transform transform, Color toColor, bool useRecursion = true ){
Renderer ren = transform.gameObject.GetComponent<Renderer>();
if(ren!=null){
foreach(Material mat in ren.materials){
mat.color = toColor;
}
}
if(useRecursion && transform.childCount>0){
foreach (Transform child in transform) {
colorRecursive(child, toColor);
}
}
}
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
private static void alphaRecursive( RectTransform rectTransform, float val, int recursiveLevel = 0){
if(rectTransform.childCount>0){
foreach (RectTransform child in rectTransform) {
UnityEngine.UI.MaskableGraphic uiImage = child.GetComponent<UnityEngine.UI.Image>();
if (uiImage != null) {
Color c = uiImage.color; c.a = val; uiImage.color = c;
} else {
uiImage = child.GetComponent<UnityEngine.UI.RawImage>();
if (uiImage != null) {
Color c = uiImage.color; c.a = val; uiImage.color = c;
}
}
alphaRecursive(child, val, recursiveLevel + 1);
}
}
}
private static void alphaRecursiveSprite( Transform transform, float val ){
if(transform.childCount>0){
foreach (Transform child in transform) {
SpriteRenderer ren = child.GetComponent<SpriteRenderer>();
if(ren!=null)
ren.color = new Color( ren.color.r, ren.color.g, ren.color.b, val);
alphaRecursiveSprite(child, val);
}
}
}
private static void colorRecursiveSprite( Transform transform, Color toColor ){
if(transform.childCount>0){
foreach (Transform child in transform) {
SpriteRenderer ren = transform.gameObject.GetComponent<SpriteRenderer>();
if(ren!=null)
ren.color = toColor;
colorRecursiveSprite(child, toColor);
}
}
}
private static void colorRecursive( RectTransform rectTransform, Color toColor ){
if(rectTransform.childCount>0){
foreach (RectTransform child in rectTransform) {
UnityEngine.UI.MaskableGraphic uiImage = child.GetComponent<UnityEngine.UI.Image>();
if (uiImage != null) {
uiImage.color = toColor;
} else {
uiImage = child.GetComponent<UnityEngine.UI.RawImage>();
if (uiImage != null)
uiImage.color = toColor;
}
colorRecursive(child, toColor);
}
}
}
private static void textAlphaChildrenRecursive( Transform trans, float val, bool useRecursion = true ){
if(useRecursion && trans.childCount>0){
foreach (Transform child in trans) {
UnityEngine.UI.Text uiText = child.GetComponent<UnityEngine.UI.Text>();
if(uiText!=null){
Color c = uiText.color;
c.a = val;
uiText.color = c;
}
textAlphaChildrenRecursive(child, val);
}
}
}
private static void textAlphaRecursive( Transform trans, float val, bool useRecursion = true ){
UnityEngine.UI.Text uiText = trans.GetComponent<UnityEngine.UI.Text>();
if(uiText!=null){
Color c = uiText.color;
c.a = val;
uiText.color = c;
}
if(useRecursion && trans.childCount>0){
foreach (Transform child in trans) {
textAlphaRecursive(child, val);
}
}
}
private static void textColorRecursive(Transform trans, Color toColor ){
if(trans.childCount>0){
foreach (Transform child in trans) {
UnityEngine.UI.Text uiText = child.GetComponent<UnityEngine.UI.Text>();
if(uiText!=null){
uiText.color = toColor;
}
textColorRecursive(child, toColor);
}
}
}
#endif
private static Color tweenColor( LTDescr tween, float val ){
Vector3 diff3 = tween._optional.point - tween._optional.axis;
float diffAlpha = tween.to.y - tween.from.y;
return new Color(tween._optional.axis.x + diff3.x*val, tween._optional.axis.y + diff3.y*val, tween._optional.axis.z + diff3.z*val, tween.from.y + diffAlpha*val);
}
/**
* Pause a tween
*
* @method pause
* @return {LTDescr} LTDescr an object that distinguishes the tween
*/
public LTDescr pause(){
if(this.direction != 0.0f){ // check if tween is already paused
this.directionLast = this.direction;
this.direction = 0.0f;
}
return this;
}
/**
* Resume a paused tween
*
* @method resume
* @return {LTDescr} LTDescr an object that distinguishes the tween
*/
public LTDescr resume(){
this.direction = this.directionLast;
return this;
}
/**
* Set Axis optional axis for tweens where it is relevant
*
* @method setAxis
* @param {Vector3} axis either the tween rotates around, or the direction it faces in the case of setOrientToPath
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.move( ltLogo, path, 1.0f ).setEase(LeanTweenType.easeOutQuad).setOrientToPath(true).setAxis(Vector3.forward);
*/
public LTDescr setAxis( Vector3 axis ){
this._optional.axis = axis;
return this;
}
/**
* Delay the start of a tween
*
* @method setDelay
* @param {float} float time The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setDelay( 1.5f );
*/
public LTDescr setDelay( float delay ){
this.delay = delay;
return this;
}
/**
* Set the type of easing used for the tween. <br>
* <ul><li><a href="LeanTweenType.html">List of all the ease types</a>.</li>
* <li><a href="http://www.robertpenner.com/easing/easing_demo.html">This page helps visualize the different easing equations</a></li>
* </ul>
*
* @method setEase
* @param {LeanTweenType} easeType:LeanTweenType the easing type to use
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setEase( LeanTweenType.easeInBounce );
*/
public LTDescr setEase( LeanTweenType easeType ){
switch( easeType ){
case LeanTweenType.linear:
setEaseLinear(); break;
case LeanTweenType.easeOutQuad:
setEaseOutQuad(); break;
case LeanTweenType.easeInQuad:
setEaseInQuad(); break;
case LeanTweenType.easeInOutQuad:
setEaseInOutQuad(); break;
case LeanTweenType.easeInCubic:
setEaseInCubic();break;
case LeanTweenType.easeOutCubic:
setEaseOutCubic(); break;
case LeanTweenType.easeInOutCubic:
setEaseInOutCubic(); break;
case LeanTweenType.easeInQuart:
setEaseInQuart(); break;
case LeanTweenType.easeOutQuart:
setEaseOutQuart(); break;
case LeanTweenType.easeInOutQuart:
setEaseInOutQuart(); break;
case LeanTweenType.easeInQuint:
setEaseInQuint(); break;
case LeanTweenType.easeOutQuint:
setEaseOutQuint(); break;
case LeanTweenType.easeInOutQuint:
setEaseInOutQuint(); break;
case LeanTweenType.easeInSine:
setEaseInSine(); break;
case LeanTweenType.easeOutSine:
setEaseOutSine(); break;
case LeanTweenType.easeInOutSine:
setEaseInOutSine(); break;
case LeanTweenType.easeInExpo:
setEaseInExpo(); break;
case LeanTweenType.easeOutExpo:
setEaseOutExpo(); break;
case LeanTweenType.easeInOutExpo:
setEaseInOutExpo(); break;
case LeanTweenType.easeInCirc:
setEaseInCirc(); break;
case LeanTweenType.easeOutCirc:
setEaseOutCirc(); break;
case LeanTweenType.easeInOutCirc:
setEaseInOutCirc(); break;
case LeanTweenType.easeInBounce:
setEaseInBounce(); break;
case LeanTweenType.easeOutBounce:
setEaseOutBounce(); break;
case LeanTweenType.easeInOutBounce:
setEaseInOutBounce(); break;
case LeanTweenType.easeInBack:
setEaseInBack(); break;
case LeanTweenType.easeOutBack:
setEaseOutBack(); break;
case LeanTweenType.easeInOutBack:
setEaseInOutBack(); break;
case LeanTweenType.easeInElastic:
setEaseInElastic(); break;
case LeanTweenType.easeOutElastic:
setEaseOutElastic(); break;
case LeanTweenType.easeInOutElastic:
setEaseInOutElastic(); break;
case LeanTweenType.punch:
setEasePunch(); break;
case LeanTweenType.easeShake:
setEaseShake(); break;
case LeanTweenType.easeSpring:
setEaseSpring(); break;
default:
setEaseLinear(); break;
}
return this;
}
public LTDescr setEaseLinear(){ this.easeType = LeanTweenType.linear; this.easeMethod = this.easeLinear; return this; }
public LTDescr setEaseSpring(){ this.easeType = LeanTweenType.easeSpring; this.easeMethod = this.easeSpring; return this; }
public LTDescr setEaseInQuad(){ this.easeType = LeanTweenType.easeInQuad; this.easeMethod = this.easeInQuad; return this; }
public LTDescr setEaseOutQuad(){ this.easeType = LeanTweenType.easeOutQuad; this.easeMethod = this.easeOutQuad; return this; }
public LTDescr setEaseInOutQuad(){ this.easeType = LeanTweenType.easeInOutQuad; this.easeMethod = this.easeInOutQuad; return this;}
public LTDescr setEaseInCubic(){ this.easeType = LeanTweenType.easeInCubic; this.easeMethod = this.easeInCubic; return this; }
public LTDescr setEaseOutCubic(){ this.easeType = LeanTweenType.easeOutCubic; this.easeMethod = this.easeOutCubic; return this; }
public LTDescr setEaseInOutCubic(){ this.easeType = LeanTweenType.easeInOutCubic; this.easeMethod = this.easeInOutCubic; return this; }
public LTDescr setEaseInQuart(){ this.easeType = LeanTweenType.easeInQuart; this.easeMethod = this.easeInQuart; return this; }
public LTDescr setEaseOutQuart(){ this.easeType = LeanTweenType.easeOutQuart; this.easeMethod = this.easeOutQuart; return this; }
public LTDescr setEaseInOutQuart(){ this.easeType = LeanTweenType.easeInOutQuart; this.easeMethod = this.easeInOutQuart; return this; }
public LTDescr setEaseInQuint(){ this.easeType = LeanTweenType.easeInQuint; this.easeMethod = this.easeInQuint; return this; }
public LTDescr setEaseOutQuint(){ this.easeType = LeanTweenType.easeOutQuint; this.easeMethod = this.easeOutQuint; return this; }
public LTDescr setEaseInOutQuint(){ this.easeType = LeanTweenType.easeInOutQuint; this.easeMethod = this.easeInOutQuint; return this; }
public LTDescr setEaseInSine(){ this.easeType = LeanTweenType.easeInSine; this.easeMethod = this.easeInSine; return this; }
public LTDescr setEaseOutSine(){ this.easeType = LeanTweenType.easeOutSine; this.easeMethod = this.easeOutSine; return this; }
public LTDescr setEaseInOutSine(){ this.easeType = LeanTweenType.easeInOutSine; this.easeMethod = this.easeInOutSine; return this; }
public LTDescr setEaseInExpo(){ this.easeType = LeanTweenType.easeInExpo; this.easeMethod = this.easeInExpo; return this; }
public LTDescr setEaseOutExpo(){ this.easeType = LeanTweenType.easeOutExpo; this.easeMethod = this.easeOutExpo; return this; }
public LTDescr setEaseInOutExpo(){ this.easeType = LeanTweenType.easeInOutExpo; this.easeMethod = this.easeInOutExpo; return this; }
public LTDescr setEaseInCirc(){ this.easeType = LeanTweenType.easeInCirc; this.easeMethod = this.easeInCirc; return this; }
public LTDescr setEaseOutCirc(){ this.easeType = LeanTweenType.easeOutCirc; this.easeMethod = this.easeOutCirc; return this; }
public LTDescr setEaseInOutCirc(){ this.easeType = LeanTweenType.easeInOutCirc; this.easeMethod = this.easeInOutCirc; return this; }
public LTDescr setEaseInBounce(){ this.easeType = LeanTweenType.easeInBounce; this.easeMethod = this.easeInBounce; return this; }
public LTDescr setEaseOutBounce(){ this.easeType = LeanTweenType.easeOutBounce; this.easeMethod = this.easeOutBounce; return this; }
public LTDescr setEaseInOutBounce(){ this.easeType = LeanTweenType.easeInOutBounce; this.easeMethod = this.easeInOutBounce; return this; }
public LTDescr setEaseInBack(){ this.easeType = LeanTweenType.easeInBack; this.easeMethod = this.easeInBack; return this; }
public LTDescr setEaseOutBack(){ this.easeType = LeanTweenType.easeOutBack; this.easeMethod = this.easeOutBack; return this; }
public LTDescr setEaseInOutBack(){ this.easeType = LeanTweenType.easeInOutBack; this.easeMethod = this.easeInOutBack; return this; }
public LTDescr setEaseInElastic(){ this.easeType = LeanTweenType.easeInElastic; this.easeMethod = this.easeInElastic; return this; }
public LTDescr setEaseOutElastic(){ this.easeType = LeanTweenType.easeOutElastic; this.easeMethod = this.easeOutElastic; return this; }
public LTDescr setEaseInOutElastic(){ this.easeType = LeanTweenType.easeInOutElastic; this.easeMethod = this.easeInOutElastic; return this; }
public LTDescr setEasePunch(){ this._optional.animationCurve = LeanTween.punch; this.toInternal.x = this.from.x + this.to.x; this.easeMethod = this.tweenOnCurve; return this; }
public LTDescr setEaseShake(){ this._optional.animationCurve = LeanTween.shake; this.toInternal.x = this.from.x + this.to.x; this.easeMethod = this.tweenOnCurve; return this; }
private Vector3 tweenOnCurve(){
return new Vector3(this.from.x + (this.diff.x) * this._optional.animationCurve.Evaluate(ratioPassed),
this.from.y + (this.diff.y) * this._optional.animationCurve.Evaluate(ratioPassed),
this.from.z + (this.diff.z) * this._optional.animationCurve.Evaluate(ratioPassed) );
}
// Vector3 Ease Methods
private Vector3 easeInOutQuad(){
val = this.ratioPassed * 2f;
if (val < 1f) {
val = val * val;
return new Vector3( this.diffDiv2.x * val + this.from.x, this.diffDiv2.y * val + this.from.y, this.diffDiv2.z * val + this.from.z);
}
val = (1f-val) * (val - 3f) + 1f;
return new Vector3( this.diffDiv2.x * val + this.from.x, this.diffDiv2.y * val + this.from.y, this.diffDiv2.z * val + this.from.z);
}
private Vector3 easeInQuad(){
val = ratioPassed * ratioPassed;
return new Vector3(this.diff.x * val + this.from.x, this.diff.y * val + this.from.y, this.diff.z * val + this.from.z);
}
private Vector3 easeOutQuad(){
val = this.ratioPassed;
val = -val * (val - 2f);
return (this.diff * val + this.from);
}
private Vector3 easeLinear(){
val = this.ratioPassed;
return new Vector3(this.from.x+this.diff.x*val, this.from.y+this.diff.y*val, this.from.z+this.diff.z*val);
}
private Vector3 easeSpring(){
val = Mathf.Clamp01(this.ratioPassed);
val = (Mathf.Sin(val * Mathf.PI * (0.2f + 2.5f * val * val * val)) * Mathf.Pow(1f - val, 2.2f ) + val) * (1f + (1.2f * (1f - val) ));
return this.from + this.diff * val;
}
private Vector3 easeInCubic(){
val = this.ratioPassed * this.ratioPassed * this.ratioPassed;
return new Vector3(this.diff.x * val + this.from.x, this.diff.y * val + this.from.y, this.diff.z * val + this.from.z);
}
private Vector3 easeOutCubic(){
val = this.ratioPassed - 1f;
val = (val * val * val + 1);
return new Vector3( this.diff.x * val + this.from.x, this.diff.y * val + this.from.y, this.diff.z * val + this.from.z) ;
}
private Vector3 easeInOutCubic(){
val = this.ratioPassed * 2f;
if (val < 1f) {
val = val * val * val;
return new Vector3(this.diffDiv2.x * val + this.from.x, this.diffDiv2.y * val + this.from.y, this.diffDiv2.z * val + this.from.z);
}
val -= 2f;
val = val * val * val + 2f;
return new Vector3(this.diffDiv2.x * val + this.from.x, this.diffDiv2.y * val + this.from.y,this.diffDiv2.z * val + this.from.z);
}
private Vector3 easeInQuart(){
val = this.ratioPassed * this.ratioPassed * this.ratioPassed * this.ratioPassed;
return diff * val + this.from;
}
private Vector3 easeOutQuart(){
val = this.ratioPassed - 1f;
val = -(val * val * val * val - 1);
return new Vector3(this.diff.x * val + this.from.x, this.diff.y * val + this.from.y,this.diff.z * val + this.from.z);
}
private Vector3 easeInOutQuart(){
val = this.ratioPassed * 2f;
if (val < 1f) {
val = val * val * val * val;
return new Vector3(this.diffDiv2.x * val + this.from.x, this.diffDiv2.y * val + this.from.y, this.diffDiv2.z * val + this.from.z);
}
val -= 2f;
// val = (val * val * val * val - 2f);
return -this.diffDiv2 * (val * val * val * val - 2f) + this.from;
}
private Vector3 easeInQuint(){
val = this.ratioPassed;
val = val * val * val * val * val;
return new Vector3(this.diff.x * val + this.from.x, this.diff.y * val + this.from.y, this.diff.z * val + this.from.z);
}
private Vector3 easeOutQuint(){
val = this.ratioPassed - 1f;
val = (val * val * val * val * val + 1f);
return new Vector3(this.diff.x * val + this.from.x, this.diff.y * val + this.from.y, this.diff.z * val + this.from.z);
}
private Vector3 easeInOutQuint(){
val = this.ratioPassed * 2f;
if (val < 1f){
val = val * val * val * val * val;
return new Vector3(this.diffDiv2.x * val + this.from.x,this.diffDiv2.y * val + this.from.y,this.diffDiv2.z * val + this.from.z);
}
val -= 2f;
val = (val * val * val * val * val + 2f);
return new Vector3(this.diffDiv2.x * val + this.from.x, this.diffDiv2.y * val + this.from.y, this.diffDiv2.z * val + this.from.z);
}
private Vector3 easeInSine(){
val = - Mathf.Cos(this.ratioPassed * LeanTween.PI_DIV2);
return new Vector3(this.diff.x * val + this.diff.x + this.from.x, this.diff.y * val + this.diff.y + this.from.y, this.diff.z * val + this.diff.z + this.from.z);
}
private Vector3 easeOutSine(){
val = Mathf.Sin(this.ratioPassed * LeanTween.PI_DIV2);
return new Vector3(this.diff.x * val + this.from.x, this.diff.y * val + this.from.y,this.diff.z * val + this.from.z);
}
private Vector3 easeInOutSine(){
val = -(Mathf.Cos(Mathf.PI * this.ratioPassed) - 1f);
return new Vector3(this.diffDiv2.x * val + this.from.x, this.diffDiv2.y * val + this.from.y, this.diffDiv2.z * val + this.from.z);
}
private Vector3 easeInExpo(){
val = Mathf.Pow(2f, 10f * (this.ratioPassed - 1f));
return new Vector3(this.diff.x * val + this.from.x, this.diff.y * val + this.from.y, this.diff.z * val + this.from.z);
}
private Vector3 easeOutExpo(){
val = (-Mathf.Pow(2f, -10f * this.ratioPassed) + 1f);
return new Vector3(this.diff.x * val + this.from.x, this.diff.y * val + this.from.y, this.diff.z * val + this.from.z);
}
private Vector3 easeInOutExpo(){
val = this.ratioPassed * 2f;
if (val < 1) return this.diffDiv2 * Mathf.Pow(2, 10 * (val - 1)) + this.from;
val--;
return this.diffDiv2 * (-Mathf.Pow(2, -10 * val) + 2) + this.from;
}
private Vector3 easeInCirc(){
val = -(Mathf.Sqrt(1f - this.ratioPassed * this.ratioPassed) - 1f);
return new Vector3(this.diff.x * val + this.from.x, this.diff.y * val + this.from.y, this.diff.z * val + this.from.z);
}
private Vector3 easeOutCirc(){
val = this.ratioPassed - 1f;
val = Mathf.Sqrt(1f - val * val);
return new Vector3(this.diff.x * val + this.from.x, this.diff.y * val + this.from.y, this.diff.z * val + this.from.z);
}
private Vector3 easeInOutCirc(){
val = this.ratioPassed * 2f;
if (val < 1f){
val = -(Mathf.Sqrt(1f - val * val) - 1f);
return new Vector3(this.diffDiv2.x * val + this.from.x, this.diffDiv2.y * val + this.from.y, this.diffDiv2.z * val + this.from.z);
}
val -= 2f;
val = (Mathf.Sqrt(1f - val * val) + 1f);
return new Vector3(this.diffDiv2.x * val + this.from.x, this.diffDiv2.y * val + this.from.y, this.diffDiv2.z * val + this.from.z);
}
private Vector3 easeInBounce(){
val = this.ratioPassed;
val = 1f - val;
return new Vector3(this.diff.x - LeanTween.easeOutBounce(0, this.diff.x, val) + this.from.x,
this.diff.y - LeanTween.easeOutBounce(0, this.diff.y, val) + this.from.y,
this.diff.z - LeanTween.easeOutBounce(0, this.diff.z, val) + this.from.z);
}
private Vector3 easeOutBounce ()
{
val = ratioPassed;
float valM, valN; // bounce values
if (val < (valM = 1 - 1.75f * this.overshoot / 2.75f)) {
val = 1 / valM / valM * val * val;
} else if (val < (valN = 1 - .75f * this.overshoot / 2.75f)) {
val -= (valM + valN) / 2;
// first bounce, height: 1/4
val = 7.5625f * val * val + 1 - .25f * this.overshoot * this.overshoot;
} else if (val < (valM = 1 - .25f * this.overshoot / 2.75f)) {
val -= (valM + valN) / 2;
// second bounce, height: 1/16
val = 7.5625f * val * val + 1 - .0625f * this.overshoot * this.overshoot;
} else { // valN = 1
val -= (valM + 1) / 2;
// third bounce, height: 1/64
val = 7.5625f * val * val + 1 - .015625f * this.overshoot * this.overshoot;
}
return this.diff * val + this.from;
}
private Vector3 easeInOutBounce(){
val = this.ratioPassed * 2f;
if (val < 1f){
return new Vector3(LeanTween.easeInBounce(0, this.diff.x, val) * 0.5f + this.from.x,
LeanTween.easeInBounce(0, this.diff.y, val) * 0.5f + this.from.y,
LeanTween.easeInBounce(0, this.diff.z, val) * 0.5f + this.from.z);
}else {
val = val - 1f;
return new Vector3(LeanTween.easeOutBounce(0, this.diff.x, val) * 0.5f + this.diffDiv2.x + this.from.x,
LeanTween.easeOutBounce(0, this.diff.y, val) * 0.5f + this.diffDiv2.y + this.from.y,
LeanTween.easeOutBounce(0, this.diff.z, val) * 0.5f + this.diffDiv2.z + this.from.z);
}
}
private Vector3 easeInBack(){
val = this.ratioPassed;
val /= 1;
float s = 1.70158f * this.overshoot;
return this.diff * (val) * val * ((s + 1) * val - s) + this.from;
}
private Vector3 easeOutBack(){
float s = 1.70158f * this.overshoot;
val = (this.ratioPassed / 1) - 1;
val = ((val) * val * ((s + 1) * val + s) + 1);
return this.diff * val + this.from;
}
private Vector3 easeInOutBack(){
float s = 1.70158f * this.overshoot;
val = this.ratioPassed * 2f;
if ((val) < 1){
s *= (1.525f) * overshoot;
return this.diffDiv2 * (val * val * (((s) + 1) * val - s)) + this.from;
}
val -= 2;
s *= (1.525f) * overshoot;
val = ((val) * val * (((s) + 1) * val + s) + 2);
return this.diffDiv2 * val + this.from;
}
private Vector3 easeInElastic(){
return new Vector3(LeanTween.easeInElastic(this.from.x,this.to.x,this.ratioPassed,this.overshoot,this.period),
LeanTween.easeInElastic(this.from.y,this.to.y,this.ratioPassed,this.overshoot,this.period),
LeanTween.easeInElastic(this.from.z,this.to.z,this.ratioPassed,this.overshoot,this.period));
}
private Vector3 easeOutElastic(){
return new Vector3(LeanTween.easeOutElastic(this.from.x,this.to.x,this.ratioPassed,this.overshoot,this.period),
LeanTween.easeOutElastic(this.from.y,this.to.y,this.ratioPassed,this.overshoot,this.period),
LeanTween.easeOutElastic(this.from.z,this.to.z,this.ratioPassed,this.overshoot,this.period));
}
private Vector3 easeInOutElastic()
{
return new Vector3(LeanTween.easeInOutElastic(this.from.x,this.to.x,this.ratioPassed,this.overshoot,this.period),
LeanTween.easeInOutElastic(this.from.y,this.to.y,this.ratioPassed,this.overshoot,this.period),
LeanTween.easeInOutElastic(this.from.z,this.to.z,this.ratioPassed,this.overshoot,this.period));
}
/**
* Set how far past a tween will overshoot for certain ease types (compatible: easeInBack, easeInOutBack, easeOutBack, easeOutElastic, easeInElastic, easeInOutElastic). <br>
* @method setOvershoot
* @param {float} overshoot:float how far past the destination it will go before settling in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setEase( LeanTweenType.easeOutBack ).setOvershoot(2f);
*/
public LTDescr setOvershoot( float overshoot ){
this.overshoot = overshoot;
return this;
}
/**
* Set how short the iterations are for certain ease types (compatible: easeOutElastic, easeInElastic, easeInOutElastic). <br>
* @method setPeriod
* @param {float} period:float how short the iterations are that the tween will animate at (default 0.3f)
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setEase( LeanTweenType.easeOutElastic ).setPeriod(0.3f);
*/
public LTDescr setPeriod( float period ){
this.period = period;
return this;
}
/**
* Set how large the effect is for certain ease types (compatible: punch, shake, animation curves). <br>
* @method setScale
* @param {float} scale:float how much the ease will be multiplied by (default 1f)
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setEase( LeanTweenType.punch ).setScale(2f);
*/
public LTDescr setScale( float scale ){
this.scale = scale;
return this;
}
/**
* Set the type of easing used for the tween with a custom curve. <br>
* @method setEase (AnimationCurve)
* @param {AnimationCurve} easeDefinition:AnimationCurve an <a href="http://docs.unity3d.com/Documentation/ScriptReference/AnimationCurve.html" target="_blank">AnimationCure</a> that describes the type of easing you want, this is great for when you want a unique type of movement
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setEase( LeanTweenType.easeInBounce );
*/
public LTDescr setEase( AnimationCurve easeCurve ){
this._optional.animationCurve = easeCurve;
this.easeMethod = this.tweenOnCurve;
this.easeType = LeanTweenType.animationCurve;
return this;
}
/**
* Set the end that the GameObject is tweening towards
* @method setTo
* @param {Vector3} to:Vector3 point at which you want the tween to reach
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LTDescr descr = LeanTween.move( cube, Vector3.up, new Vector3(1f,3f,0f), 1.0f ).setEase( LeanTweenType.easeInOutBounce );<br>
* // Later your want to change your destination or your destiation is constantly moving<br>
* descr.setTo( new Vector3(5f,10f,3f) );<br>
*/
public LTDescr setTo( Vector3 to ){
if(this.hasInitiliazed){
this.to = to;
this.diff = to - this.from;
}else{
this.to = to;
}
return this;
}
public LTDescr setTo( Transform to ){
this._optional.toTrans = to;
return this;
}
/**
* Set the beginning of the tween
* @method setFrom
* @param {Vector3} from:Vector3 the point you would like the tween to start at
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LTDescr descr = LeanTween.move( cube, Vector3.up, new Vector3(1f,3f,0f), 1.0f ).setFrom( new Vector3(5f,10f,3f) );<br>
*/
public LTDescr setFrom( Vector3 from ){
if(this.trans){
this.init();
}
this.from = from;
// this.hasInitiliazed = true; // this is set, so that the "from" value isn't overwritten later on when the tween starts
this.diff = this.to - this.from;
this.diffDiv2 = this.diff * 0.5f;
return this;
}
public LTDescr setFrom( float from ){
return setFrom( new Vector3(from, 0f, 0f) );
}
public LTDescr setDiff( Vector3 diff ){
this.diff = diff;
return this;
}
public LTDescr setHasInitialized( bool has ){
this.hasInitiliazed = has;
return this;
}
public LTDescr setId( uint id, uint global_counter ){
this._id = id;
this.counter = global_counter;
// Debug.Log("Global counter:"+global_counter);
return this;
}
/**
* Set the point of time the tween will start in
* @method setPassed
* @param {float} passedTime:float the length of time in seconds the tween will start in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* int tweenId = LeanTween.moveX(gameObject, 5f, 2.0f ).id;<br>
* // Later<br>
* LTDescr descr = description( tweenId );<br>
* descr.setPassed( 1f );<br>
*/
public LTDescr setPassed( float passed ){
this.passed = passed;
return this;
}
/**
* Set the finish time of the tween
* @method setTime
* @param {float} finishTime:float the length of time in seconds you wish the tween to complete in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* int tweenId = LeanTween.moveX(gameObject, 5f, 2.0f ).id;<br>
* // Later<br>
* LTDescr descr = description( tweenId );<br>
* descr.setTime( 1f );<br>
*/
public LTDescr setTime( float time ){
float passedTimeRatio = this.passed / this.time;
this.passed = time * passedTimeRatio;
this.time = time;
return this;
}
/**
* Set the finish time of the tween
* @method setSpeed
* @param {float} speed:float the speed in unity units per second you wish the object to travel (overrides the given time)
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveLocalZ( gameObject, 10f, 1f).setSpeed(0.2f) // the given time is ignored when speed is set<br>
*/
public LTDescr setSpeed( float speed ){
this.speed = speed;
if(this.hasInitiliazed)
initSpeed();
return this;
}
/**
* Set the tween to repeat a number of times.
* @method setRepeat
* @param {int} repeatNum:int the number of times to repeat the tween. -1 to repeat infinite times
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setRepeat( 10 ).setLoopPingPong();
*/
public LTDescr setRepeat( int repeat ){
this.loopCount = repeat;
if((repeat>1 && this.loopType == LeanTweenType.once) || (repeat < 0 && this.loopType == LeanTweenType.once)){
this.loopType = LeanTweenType.clamp;
}
if(this.type==TweenAction.CALLBACK || this.type==TweenAction.CALLBACK_COLOR){
this.setOnCompleteOnRepeat(true);
}
return this;
}
public LTDescr setLoopType( LeanTweenType loopType ){
this.loopType = loopType;
return this;
}
public LTDescr setUseEstimatedTime( bool useEstimatedTime ){
this.useEstimatedTime = useEstimatedTime;
this.usesNormalDt = false;
return this;
}
/**
* Set ignore time scale when tweening an object when you want the animation to be time-scale independent (ignores the Time.timeScale value). Great for pause screens, when you want all other action to be stopped (or slowed down)
* @method setIgnoreTimeScale
* @param {bool} useUnScaledTime:bool whether to use the unscaled time or not
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setRepeat( 2 ).setIgnoreTimeScale( true );
*/
public LTDescr setIgnoreTimeScale( bool useUnScaledTime ){
this.useEstimatedTime = useUnScaledTime;
this.usesNormalDt = false;
return this;
}
/**
* Use frames when tweening an object, when you don't want the animation to be time-frame independent...
* @method setUseFrames
* @param {bool} useFrames:bool whether to use estimated time or not
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setRepeat( 2 ).setUseFrames( true );
*/
public LTDescr setUseFrames( bool useFrames ){
this.useFrames = useFrames;
this.usesNormalDt = false;
return this;
}
public LTDescr setUseManualTime( bool useManualTime ){
this.useManualTime = useManualTime;
this.usesNormalDt = false;
return this;
}
public LTDescr setLoopCount( int loopCount ){
this.loopType = LeanTweenType.clamp;
this.loopCount = loopCount;
return this;
}
/**
* No looping involved, just run once (the default)
* @method setLoopOnce
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setLoopOnce();
*/
public LTDescr setLoopOnce(){ this.loopType = LeanTweenType.once; return this; }
/**
* When the animation gets to the end it starts back at where it began
* @method setLoopClamp
* @param {int} loops:int (defaults to -1) how many times you want the loop to happen (-1 for an infinite number of times)
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setLoopClamp( 2 );
*/
public LTDescr setLoopClamp(){
this.loopType = LeanTweenType.clamp;
if(this.loopCount==0)
this.loopCount = -1;
return this;
}
public LTDescr setLoopClamp( int loops ){
this.loopCount = loops;
return this;
}
/**
* When the animation gets to the end it then tweens back to where it started (and on, and on)
* @method setLoopPingPong
* @param {int} loops:int (defaults to -1) how many times you want the loop to happen in both directions (-1 for an infinite number of times). Passing a value of 1 will cause the object to go towards and back from it's destination once.
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setLoopPingPong( 2 );
*/
public LTDescr setLoopPingPong(){
this.loopType = LeanTweenType.pingPong;
if(this.loopCount==0)
this.loopCount = -1;
return this;
}
public LTDescr setLoopPingPong( int loops ) {
this.loopType = LeanTweenType.pingPong;
this.loopCount = loops == -1 ? loops : loops * 2;
return this;
}
/**
* Have a method called when the tween finishes
* @method setOnComplete
* @param {Action} onComplete:Action the method that should be called when the tween is finished ex: tweenFinished(){ }
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnComplete( tweenFinished );
*/
public LTDescr setOnComplete( Action onComplete ){
this._optional.onComplete = onComplete;
this.hasExtraOnCompletes = true;
return this;
}
/**
* Have a method called when the tween finishes
* @method setOnComplete (object)
* @param {Action<object>} onComplete:Action<object> the method that should be called when the tween is finished ex: tweenFinished( object myObj ){ }
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* object tweenFinishedObj = "hi" as object;
* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnComplete( tweenFinished, tweenFinishedObj );
*/
public LTDescr setOnComplete( Action<object> onComplete ){
this._optional.onCompleteObject = onComplete;
this.hasExtraOnCompletes = true;
return this;
}
public LTDescr setOnComplete( Action<object> onComplete, object onCompleteParam ){
this._optional.onCompleteObject = onComplete;
this.hasExtraOnCompletes = true;
if(onCompleteParam!=null)
this._optional.onCompleteParam = onCompleteParam;
return this;
}
/**
* Pass an object to along with the onComplete Function
* @method setOnCompleteParam
* @param {object} onComplete:object an object that
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.delayedCall(1.5f, enterMiniGameStart).setOnCompleteParam( new object[]{""+5} );<br><br>
* void enterMiniGameStart( object val ){<br>
* &nbsp;object[] arr = (object [])val;<br>
* &nbsp;int lvl = int.Parse((string)arr[0]);<br>
* }<br>
*/
public LTDescr setOnCompleteParam( object onCompleteParam ){
this._optional.onCompleteParam = onCompleteParam;
this.hasExtraOnCompletes = true;
return this;
}
/**
* Have a method called on each frame that the tween is being animated (passes a float value)
* @method setOnUpdate
* @param {Action<float>} onUpdate:Action<float> a method that will be called on every frame with the float value of the tweened object
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnUpdate( tweenMoved );<br>
* <br>
* void tweenMoved( float val ){ }<br>
*/
public LTDescr setOnUpdate( Action<float> onUpdate ){
this._optional.onUpdateFloat = onUpdate;
this.hasUpdateCallback = true;
return this;
}
public LTDescr setOnUpdateRatio(Action<float,float> onUpdate)
{
this._optional.onUpdateFloatRatio = onUpdate;
this.hasUpdateCallback = true;
return this;
}
public LTDescr setOnUpdateObject( Action<float,object> onUpdate ){
this._optional.onUpdateFloatObject = onUpdate;
this.hasUpdateCallback = true;
return this;
}
public LTDescr setOnUpdateVector2( Action<Vector2> onUpdate ){
this._optional.onUpdateVector2 = onUpdate;
this.hasUpdateCallback = true;
return this;
}
public LTDescr setOnUpdateVector3( Action<Vector3> onUpdate ){
this._optional.onUpdateVector3 = onUpdate;
this.hasUpdateCallback = true;
return this;
}
public LTDescr setOnUpdateColor( Action<Color> onUpdate ){
this._optional.onUpdateColor = onUpdate;
this.hasUpdateCallback = true;
return this;
}
public LTDescr setOnUpdateColor( Action<Color,object> onUpdate ){
this._optional.onUpdateColorObject = onUpdate;
this.hasUpdateCallback = true;
return this;
}
#if !UNITY_FLASH
public LTDescr setOnUpdate( Action<Color> onUpdate ){
this._optional.onUpdateColor = onUpdate;
this.hasUpdateCallback = true;
return this;
}
public LTDescr setOnUpdate( Action<Color,object> onUpdate ){
this._optional.onUpdateColorObject = onUpdate;
this.hasUpdateCallback = true;
return this;
}
/**
* Have a method called on each frame that the tween is being animated (passes a float value and a object)
* @method setOnUpdate (object)
* @param {Action<float,object>} onUpdate:Action<float,object> a method that will be called on every frame with the float value of the tweened object, and an object of the person's choosing
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnUpdate( tweenMoved ).setOnUpdateParam( myObject );<br>
* <br>
* void tweenMoved( float val, object obj ){ }<br>
*/
public LTDescr setOnUpdate( Action<float,object> onUpdate, object onUpdateParam = null ){
this._optional.onUpdateFloatObject = onUpdate;
this.hasUpdateCallback = true;
if(onUpdateParam!=null)
this._optional.onUpdateParam = onUpdateParam;
return this;
}
public LTDescr setOnUpdate( Action<Vector3,object> onUpdate, object onUpdateParam = null ){
this._optional.onUpdateVector3Object = onUpdate;
this.hasUpdateCallback = true;
if(onUpdateParam!=null)
this._optional.onUpdateParam = onUpdateParam;
return this;
}
public LTDescr setOnUpdate( Action<Vector2> onUpdate, object onUpdateParam = null ){
this._optional.onUpdateVector2 = onUpdate;
this.hasUpdateCallback = true;
if(onUpdateParam!=null)
this._optional.onUpdateParam = onUpdateParam;
return this;
}
/**
* Have a method called on each frame that the tween is being animated (passes a float value)
* @method setOnUpdate (Vector3)
* @param {Action<Vector3>} onUpdate:Action<Vector3> a method that will be called on every frame with the float value of the tweened object
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnUpdate( tweenMoved );<br>
* <br>
* void tweenMoved( Vector3 val ){ }<br>
*/
public LTDescr setOnUpdate( Action<Vector3> onUpdate, object onUpdateParam = null ){
this._optional.onUpdateVector3 = onUpdate;
this.hasUpdateCallback = true;
if(onUpdateParam!=null)
this._optional.onUpdateParam = onUpdateParam;
return this;
}
#endif
/**
* Have an object passed along with the onUpdate method
* @method setOnUpdateParam
* @param {object} onUpdateParam:object an object that will be passed along with the onUpdate method
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnUpdate( tweenMoved ).setOnUpdateParam( myObject );<br>
* <br>
* void tweenMoved( float val, object obj ){ }<br>
*/
public LTDescr setOnUpdateParam( object onUpdateParam ){
this._optional.onUpdateParam = onUpdateParam;
return this;
}
/**
* While tweening along a curve, set this property to true, to be perpendicalur to the path it is moving upon
* @method setOrientToPath
* @param {bool} doesOrient:bool whether the gameobject will orient to the path it is animating along
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.move( ltLogo, path, 1.0f ).setEase(LeanTweenType.easeOutQuad).setOrientToPath(true).setAxis(Vector3.forward);<br>
*/
public LTDescr setOrientToPath( bool doesOrient ){
if(this.type==TweenAction.MOVE_CURVED || this.type==TweenAction.MOVE_CURVED_LOCAL){
if(this._optional.path==null)
this._optional.path = new LTBezierPath();
this._optional.path.orientToPath = doesOrient;
}else{
this._optional.spline.orientToPath = doesOrient;
}
return this;
}
/**
* While tweening along a curve, set this property to true, to be perpendicalur to the path it is moving upon
* @method setOrientToPath2d
* @param {bool} doesOrient:bool whether the gameobject will orient to the path it is animating along
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.move( ltLogo, path, 1.0f ).setEase(LeanTweenType.easeOutQuad).setOrientToPath2d(true).setAxis(Vector3.forward);<br>
*/
public LTDescr setOrientToPath2d( bool doesOrient2d ){
setOrientToPath(doesOrient2d);
if(this.type==TweenAction.MOVE_CURVED || this.type==TweenAction.MOVE_CURVED_LOCAL){
this._optional.path.orientToPath2d = doesOrient2d;
}else{
this._optional.spline.orientToPath2d = doesOrient2d;
}
return this;
}
public LTDescr setRect( LTRect rect ){
this._optional.ltRect = rect;
return this;
}
public LTDescr setRect( Rect rect ){
this._optional.ltRect = new LTRect(rect);
return this;
}
public LTDescr setPath( LTBezierPath path ){
this._optional.path = path;
return this;
}
/**
* Set the point at which the GameObject will be rotated around
* @method setPoint
* @param {Vector3} point:Vector3 point at which you want the object to rotate around (local space)
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.rotateAround( cube, Vector3.up, 360.0f, 1.0f ) .setPoint( new Vector3(1f,0f,0f) ) .setEase( LeanTweenType.easeInOutBounce );<br>
*/
public LTDescr setPoint( Vector3 point ){
this._optional.point = point;
return this;
}
public LTDescr setDestroyOnComplete( bool doesDestroy ){
this.destroyOnComplete = doesDestroy;
return this;
}
public LTDescr setAudio( object audio ){
this._optional.onCompleteParam = audio;
return this;
}
/**
* Set the onComplete method to be called at the end of every loop cycle (also applies to the delayedCall method)
* @method setOnCompleteOnRepeat
* @param {bool} isOn:bool does call onComplete on every loop cycle
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.delayedCall(gameObject,0.3f, delayedMethod).setRepeat(4).setOnCompleteOnRepeat(true);
*/
public LTDescr setOnCompleteOnRepeat( bool isOn ){
this.onCompleteOnRepeat = isOn;
return this;
}
/**
* Set the onComplete method to be called at the beginning of the tween (it will still be called when it is completed as well)
* @method setOnCompleteOnStart
* @param {bool} isOn:bool does call onComplete at the start of the tween
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.delayedCall(gameObject, 2f, ()=>{<br> // Flash an object 5 times
* &nbsp;LeanTween.alpha(gameObject, 0f, 1f);<br>
* &nbsp;LeanTween.alpha(gameObject, 1f, 0f).setDelay(1f);<br>
* }).setOnCompleteOnStart(true).setRepeat(5);<br>
*/
public LTDescr setOnCompleteOnStart( bool isOn ){
this.onCompleteOnStart = isOn;
return this;
}
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
public LTDescr setRect( RectTransform rect ){
this.rectTransform = rect;
return this;
}
public LTDescr setSprites( UnityEngine.Sprite[] sprites ){
this.sprites = sprites;
return this;
}
public LTDescr setFrameRate( float frameRate ){
this.time = this.sprites.Length / frameRate;
return this;
}
#endif
/**
* Have a method called when the tween starts
* @method setOnStart
* @param {Action<>} onStart:Action<> the method that should be called when the tween is starting ex: tweenStarted( ){ }
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* <i>C#:</i><br>
* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnStart( ()=>{ Debug.Log("I started!"); });
* <i>Javascript:</i><br>
* LeanTween.moveX(gameObject, 5f, 2.0f ).setOnStart( function(){ Debug.Log("I started!"); } );
*/
public LTDescr setOnStart( Action onStart ){
this._optional.onStart = onStart;
return this;
}
/**
* Set the direction of a tween -1f for backwards 1f for forwards (currently only bezier and spline paths are supported)
* @method setDirection
* @param {float} direction:float the direction that the tween should run, -1f for backwards 1f for forwards
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.moveSpline(gameObject, new Vector3[]{new Vector3(0f,0f,0f),new Vector3(1f,0f,0f),new Vector3(1f,0f,0f),new Vector3(1f,0f,1f)}, 1.5f).setDirection(-1f);<br>
*/
public LTDescr setDirection( float direction ){
if(this.direction!=-1f && this.direction!=1f){
Debug.LogWarning("You have passed an incorrect direction of '"+direction+"', direction must be -1f or 1f");
return this;
}
if(this.direction!=direction){
// Debug.Log("reverse path:"+this.path+" spline:"+this._optional.spline+" hasInitiliazed:"+this.hasInitiliazed);
if(this.hasInitiliazed){
this.direction = direction;
}else{
if(this._optional.path!=null){
this._optional.path = new LTBezierPath( LTUtility.reverse( this._optional.path.pts ) );
}else if(this._optional.spline!=null){
this._optional.spline = new LTSpline( LTUtility.reverse( this._optional.spline.pts ) );
}
// this.passed = this.time - this.passed;
}
}
return this;
}
/**
* Set whether or not the tween will recursively effect an objects children in the hierarchy
* @method setRecursive
* @param {bool} useRecursion:bool whether the tween will recursively effect an objects children in the hierarchy
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.alpha(gameObject, 0f, 1f).setRecursive(true);<br>
*/
public LTDescr setRecursive( bool useRecursion ){
this.useRecursion = useRecursion;
return this;
}
}
//}