AlphaaeGameStudio/TEngine
1
0
Fork 0
mirror of https://github.com/Alex-Rachel/TEngine.git synced 2025-08-07 16:45:10 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
8c3d6308b96b51929f1fe7b0b200741360705cd1
TEngine/UnityProject/Assets/GameScripts/HotFix/GameLogic/LeanTween/LTDescr.cs
ALEXTANG 8c3d6308b9 Init TEngine4.0.0 
Init TEngine4.0.0
2023-10-08 15:21:33 +08:00

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