KenSchae
/
fungus
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
An easy to use Unity 3D library for creating illustrated Interactive Fiction games and more.
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.
2614 Commits
1 Branch
0 Tags
243 MiB
 
Tree: 744ba85644
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '744ba85644'
${ noResults }
fungus/Assets/Fungus/Thirdparty/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;
}
}
//}