//namespace DentedPixel{
// LeanTween version 2.43 - http://dentedpixel.com/developer-diary/
//
// The MIT License (MIT)
//
// Copyright (c) 2017 Russell Savage - Dented Pixel
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
/*
TERMS OF USE - EASING EQUATIONS#
Open source under the BSD License.
Copyright (c)2001 Robert Penner
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
Neither the name of the author nor the names of contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* Pass this to the "ease" parameter, to get a different easing behaviorExample: Index of All Methods | Optional Paramaters that can be passed Optional Parameters are passed at the end of every methodExample: LeanTweenType .easeInQuad ).setDelay(1f);Example:
* int id = LeanTween.moveX(gameObject, 1f, 1f).id;LTDescr d = LeanTween.descr ( id );// if the tween has already finished it will return null // change some parameters LeanTweenType .easeInOutBack );
*/
public static void cancelAll(){
cancelAll(false);
}
public static void cancelAll(bool callComplete){
init();
for (int i = 0; i <= tweenMaxSearch; i++)
{
if (tweens[i].trans != null){
if (callComplete && tweens[i].optional.onComplete != null)
tweens[i].optional.onComplete();
removeTween(i);
}
}
}
/**
* Cancel all tweens that are currently targeting the gameObject
*
* @method LeanTween.cancel
* @param {GameObject} gameObject:GameObject gameObject whose tweens you wish to cancel
* @param {bool} callOnComplete:bool (optional) whether to call the onComplete method before canceling
* @example LeanTween.move( gameObject, new Vector3(0f,1f,2f), 1f); // later I want decide I want to change onComplete method
* LTDescr descr = LeanTween.descr( id );// if the tween has already finished it will come back null // later I want decide I want to change onComplete method
* LTDescr[] descr = LeanTween.descriptions( gameObject );// make sure there is a valid description for this target // in this case we only ever expect there to be one tween on this object descrs = new List();
Transform trans = gameObject.transform;
for (int i = 0; i <= tweenMaxSearch; i++) {
if (tweens[i].toggle && tweens[i].trans == trans)
descrs.Add( tweens[i] );
}
return descrs.ToArray();
}
[System.Obsolete("Use 'pause( id )' instead")]
public static void pause( GameObject gameObject, int uniqueId ){
pause( uniqueId );
}
/**
* Pause all tweens for a GameObject
*
* @method LeanTween.pause
* @param {int} id:int Id of the tween you want to pause
* @example
* int id = LeanTween.moveX(gameObject, 5, 1.0).id(), sprites).setLoopPingPong();
*/
public static LTDescr play(RectTransform rectTransform, UnityEngine.Sprite[] sprites){
float defaultFrameRate = 0.25f;
float time = defaultFrameRate * sprites.Length;
return pushNewTween(rectTransform.gameObject, new Vector3((float)sprites.Length - 1.0f,0,0), time, options().setCanvasPlaySprite().setSprites( sprites ).setRepeat(-1));
}
#endif
/**
* Fade a gameobject's material to a certain alpha value. The material's shader needs to support alpha. Owl labs has some excellent efficient shaders .
*
* @method LeanTween.alpha
* @param {GameObject} gameObject:GameObject Gameobject that you wish to fade
* @param {float} to:float the final alpha value (0-1)
* @param {float} time:float The time with which to fade the object
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.alpha(gameObject, 1f, 1f) .setDelay(1f);
*/
public static LTDescr alpha(GameObject gameObject, float to, float time){
LTDescr lt = pushNewTween( gameObject, new Vector3(to,0,0), time, options().setAlpha() );
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
SpriteRenderer ren = gameObject.GetComponent();
lt.spriteRen = ren;
#endif
return lt;
}
/**
* Fade a GUI Object
*
* @method LeanTween.alpha
* @param {LTRect} ltRect:LTRect LTRect that you wish to fade
* @param {float} to:float the final alpha value (0-1)
* @param {float} time:float The time with which to fade the object
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.alpha(ltRect, 1f, 1f) .setEase(LeanTweenType.easeInCirc);
*/
public static LTDescr alpha(LTRect ltRect, float to, float time){
ltRect.alphaEnabled = true;
return pushNewTween( tweenEmpty, new Vector3(to,0f,0f), time, options().setGUIAlpha().setRect( ltRect ) );
}
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
/**
* Fade a Unity UI Object
*
* @method LeanTween.alphaText
* @param {RectTransform} rectTransform:RectTransform RectTransform associated with the Text Component you wish to fade
* @param {float} to:float the final alpha value (0-1)
* @param {float} time:float The time with which to fade the object
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.alphaText(gameObject.GetComponent<RectTransform>(), 1f, 1f) .setEase(LeanTweenType.easeInCirc);
*/
public static LTDescr textAlpha(RectTransform rectTransform, float to, float time){
return pushNewTween(rectTransform.gameObject, new Vector3(to,0,0), time, options().setTextAlpha());
}
public static LTDescr alphaText(RectTransform rectTransform, float to, float time){
return pushNewTween(rectTransform.gameObject, new Vector3(to,0,0), time, options().setTextAlpha());
}
/**
* Fade a Unity UI Canvas Group
*
* @method LeanTween.alphaCanvas
* @param {RectTransform} rectTransform:RectTransform RectTransform that the CanvasGroup is attached to
* @param {float} to:float the final alpha value (0-1)
* @param {float} time:float The time with which to fade the object
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.alphaCanvas(gameObject.GetComponent<RectTransform>(), 0f, 1f) .setLoopPingPong();
*/
public static LTDescr alphaCanvas(CanvasGroup canvasGroup, float to, float time){
return pushNewTween(canvasGroup.gameObject, new Vector3(to,0,0), time, options().setCanvasGroupAlpha());
}
#endif
/**
* This works by tweening the vertex colors directly.Owl labs has some excellent efficient shaders .
*
* @method LeanTween.color
* @param {GameObject} gameObject:GameObject Gameobject that you wish to change the color
* @param {Color} to:Color the final color value ex: Color.Red, new Color(1.0f,1.0f,0.0f,0.8f)
* @param {float} time:float The time with which to fade the object
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.color(gameObject, Color.yellow, 1f) .setDelay(1f);
*/
public static LTDescr color(GameObject gameObject, Color to, float time){
LTDescr lt = pushNewTween( gameObject, new Vector3(1.0f, to.a, 0.0f), time, options().setColor().setPoint( new Vector3(to.r, to.g, to.b) ) );
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
SpriteRenderer ren = gameObject.GetComponent();
lt.spriteRen = ren;
#endif
return lt;
}
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
/**
* Change the color a Unity UI Object
*
* @method LeanTween.colorText
* @param {RectTransform} rectTransform:RectTransform RectTransform attached to the Text Component whose color you want to change
* @param {Color} to:Color the final alpha value ex: Color.Red, new Color(1.0f,1.0f,0.0f,0.8f)
* @param {float} time:float The time with which to fade the object
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* LeanTween.colorText(gameObject.GetComponent<RectTransform>(), Color.yellow, 1f) .setDelay(1f);
*/
public static LTDescr textColor(RectTransform rectTransform, Color to, float time){
return pushNewTween(rectTransform.gameObject, new Vector3(1.0f, to.a, 0.0f), time, options().setTextColor().setPoint(new Vector3(to.r, to.g, to.b)));
}
public static LTDescr colorText(RectTransform rectTransform, Color to, float time){
return pushNewTween(rectTransform.gameObject, new Vector3(1.0f, to.a, 0.0f), time, options().setTextColor().setPoint(new Vector3(to.r, to.g, to.b)));
}
#endif
/**
* Call a method after a specified amount of time
*
* @method LeanTween.delayedCall
* @param {GameObject} gameObject:GameObject Gameobject that you wish to associate with this delayed call
* @param {float} time:float delay The time you wish to pass before the method is called
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.delayedCall(gameObject, 1f, ()=>{ callback){
return pushNewTween( tweenEmpty, Vector3.zero, delayTime, options().setCallback().setOnComplete(callback) );
}
public static LTDescr delayedCall( GameObject gameObject, float delayTime, Action callback){
return pushNewTween( gameObject, Vector3.zero, delayTime, options().setCallback().setOnComplete(callback) );
}
public static LTDescr delayedCall( GameObject gameObject, float delayTime, Action callback){
return pushNewTween( gameObject, Vector3.zero, delayTime, options().setCallback().setOnComplete(callback) );
}
public static LTDescr destroyAfter( LTRect rect, float delayTime){
return pushNewTween( tweenEmpty, Vector3.zero, delayTime, options().setCallback().setRect( rect ).setDestroyOnComplete(true) );
}
/*public static LTDescr delayedCall(GameObject gameObject, float delayTime, string callback){
return pushNewTween( gameObject, Vector3.zero, delayTime, TweenAction.CALLBACK, options().setOnComplete( callback ) );
}*/
/**
* Move a GameObject to a certain location
*
* @method LeanTween.move
* @param {GameObject} gameObject:GameObject Gameobject that you wish to move
* @param {Vector3} vec:Vector3 to The final positin with which to move to
* @param {float} time:float time The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.move(gameObject, new Vector3(0f,-3f,5f), 2.0f) .setEase( LeanTweenType.easeOutQuad );
*/
public static LTDescr move(GameObject gameObject, Vector3 to, float time){
return pushNewTween( gameObject, to, time, options().setMove() );
}
public static LTDescr move(GameObject gameObject, Vector2 to, float time){
return pushNewTween( gameObject, new Vector3(to.x, to.y, gameObject.transform.position.z), time, options().setMove() );
}
/**
* Move a GameObject along a set of bezier curves
*
* @method LeanTween.move
* @param {GameObject} gameObject:GameObject Gameobject that you wish to move
* @param {Vector3[]} path:Vector3[] A set of points that define the curve(s) ex: Point1,Handle2,Handle1,Point2,...
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* Javascript: C#: Javascript: C#: Javascript: C#: Javascript: C#: Javascript: C#: optional items .
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* if(GUI.Button(buttonRect.rect, "Rotate"))Example: Example: Example Javascript: Example C#: Example Javascript: Example C#: Example Javascript: Example C#: Example Javascript: Example C#: Example Javascript: Example C#: ();
lt.spriteRen = ren;
#endif
return lt;
}
/**
* Tween any particular value, it does not need to be tied to any particular type or GameObject
*
* @method LeanTween.value (float)
* @param {GameObject} GameObject gameObject GameObject with which to tie the tweening with. This is only used when you need to cancel this tween, it does not actually perform any operations on this gameObject
* @param {Action} callOnUpdate:Action The function that is called on every Update frame, this function needs to accept a float value ex: function updateValue( float val ){ }
* @param {float} float from The original value to start the tween from
* @param {float} float to The value to end the tween on
* @param {float} float time The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* Example Javascript: Example C#: callOnUpdate, float from, float to, float time){
return pushNewTween( gameObject, new Vector3(to,0,0), time, options().setCallback().setTo( new Vector3(to,0,0) ).setFrom( new Vector3(from,0,0) ).setOnUpdate(callOnUpdate) );
}
/**
* Tweens any float value, it does not need to be tied to any particular type or GameObject
*
* @method LeanTween.value (float)
* @param {GameObject} GameObject gameObject GameObject with which to tie the tweening with. This is only used when you need to cancel this tween, it does not actually perform any operations on this gameObject
* @param {Action} callOnUpdateRatio:Action Function that's called every Update frame. It must accept two float values ex: function updateValue( float val, float ratio){ }
* @param {float} float from The original value to start the tween from
* @param {float} float to The value to end the tween on
* @param {float} float time The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* Example Javascript: Example C#: callOnUpdateRatio, float from, float to, float time) {
return pushNewTween(gameObject, new Vector3(to, 0, 0), time, options().setCallback().setTo(new Vector3(to, 0, 0)).setFrom(new Vector3(from, 0, 0)).setOnUpdateRatio(callOnUpdateRatio));
}
/**
* Tween from one color to another
*
* @method LeanTween.value (Color)
* @param {GameObject} GameObject gameObject GameObject with which to tie the tweening with. This is only used when you need to cancel this tween, it does not actually perform any operations on this gameObject
* @param {Action} callOnUpdate:Action The function that is called on every Update frame, this function needs to accept a color value ex: function updateValue( Color val ){ }
* @param {Color} Color from The original value to start the tween from
* @param {Color} Color to The value to end the tween on
* @param {Color} Color time The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example
* Example Javascript: Example C#: callOnUpdate, Color from, Color to, float time){
return pushNewTween( gameObject, new Vector3(1.0f,to.a,0.0f), time, options().setCallbackColor().setPoint( new Vector3(to.r, to.g, to.b) )
.setAxis( new Vector3(from.r, from.g, from.b) ).setFrom( new Vector3(0.0f, from.a, 0.0f) ).setHasInitialized(false).setOnUpdateColor(callOnUpdate) );
}
public static LTDescr value(GameObject gameObject, Action callOnUpdate, Color from, Color to, float time){
return pushNewTween( gameObject, new Vector3(1.0f,to.a,0.0f), time, options().setCallbackColor().setPoint( new Vector3(to.r, to.g, to.b) )
.setAxis( new Vector3(from.r, from.g, from.b) ).setFrom( new Vector3(0.0f, from.a, 0.0f) ).setHasInitialized(false).setOnUpdateColor(callOnUpdate) );
}
/**
* Tween any particular value (Vector2), this could be used to tween an arbitrary value like offset property
*
* @method LeanTween.value (Vector2)
* @param {GameObject} gameObject:GameObject Gameobject that you wish to attach the tween to
* @param {Action} callOnUpdate:Action The function that is called on every Update frame, this function needs to accept a float value ex: function updateValue( Vector3 val ){ }
* @param {float} from:Vector2 The original value to start the tween from
* @param {Vector2} to:Vector2 The final Vector3 with which to tween to
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
*/
public static LTDescr value(GameObject gameObject, Action callOnUpdate, Vector2 from, Vector2 to, float time){
return pushNewTween( gameObject, new Vector3(to.x,to.y,0f), time, options().setValue3().setTo( new Vector3(to.x,to.y,0f) ).setFrom( new Vector3(from.x,from.y,0f) ).setOnUpdateVector2(callOnUpdate) );
}
/**
* Tween any particular value (Vector3), this could be used to tween an arbitrary property that uses a Vector
*
* @method LeanTween.value (Vector3)
* @param {GameObject} gameObject:GameObject Gameobject that you wish to attach the tween to
* @param {Action} callOnUpdate:Action The function that is called on every Update frame, this function needs to accept a float value ex: function updateValue( Vector3 val ){ }
* @param {float} from:Vector3 The original value to start the tween from
* @param {Vector3} to:Vector3 The final Vector3 with which to tween to
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
*/
public static LTDescr value(GameObject gameObject, Action callOnUpdate, Vector3 from, Vector3 to, float time){
return pushNewTween( gameObject, to, time, options().setValue3().setTo( to ).setFrom( from ).setOnUpdateVector3(callOnUpdate) );
}
/**
* Tween any particular value (float)
*
* @method LeanTween.value (float,object)
* @param {GameObject} gameObject:GameObject Gameobject that you wish to attach the tween to
* @param {Action} callOnUpdate:Action The function that is called on every Update frame, this function needs to accept a float value ex: function updateValue( Vector3 val, object obj ){ }
* @param {float} from:float The original value to start the tween from
* @param {Vector3} to:float The final Vector3 with which to tween to
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
*/
public static LTDescr value(GameObject gameObject, Action callOnUpdate, float from, float to, float time){
return pushNewTween( gameObject, new Vector3(to,0,0), time, options().setCallback().setTo( new Vector3(to,0,0) ).setFrom( new Vector3(from,0,0) ).setOnUpdate(callOnUpdate, gameObject) );
}
public static LTDescr delayedSound( AudioClip audio, Vector3 pos, float volume ){
//Debug.LogError("Delay sound??");
return pushNewTween( tweenEmpty, pos, 0f, options().setDelayedSound().setTo( pos ).setFrom( new Vector3(volume,0,0) ).setAudio( audio ) );
}
public static LTDescr delayedSound( GameObject gameObject, AudioClip audio, Vector3 pos, float volume ){
//Debug.LogError("Delay sound??");
return pushNewTween( gameObject, pos, 0f, options().setDelayedSound().setTo( pos ).setFrom( new Vector3(volume,0,0) ).setAudio( audio ) );
}
#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
/**
* Move a RectTransform object (used in Unity GUI in 4.6+, for Buttons, Panel, Scrollbar, etc...)
*
* @method LeanTween.move (RectTransform)
* @param {RectTransform} rectTrans:RectTransform RectTransform that you wish to attach the tween to
* @param {Vector3} to:Vector3 The final Vector3 with which to tween to
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.move(gameObject.GetComponent<RectTransform>(), new Vector3(200f,-100f,0f), 1f).setDelay(1f);
*/
public static LTDescr move(RectTransform rectTrans, Vector3 to, float time){
return pushNewTween( rectTrans.gameObject, to, time, options().setCanvasMove().setRect( rectTrans ) );
}
/**
* Move a RectTransform object affecting x-axis only (used in Unity GUI in 4.6+, for Buttons, Panel, Scrollbar, etc...)
*
* @method LeanTween.moveX (RectTransform)
* @param {RectTransform} rectTrans:RectTransform RectTransform that you wish to attach the tween to
* @param {float} to:float The final x location with which to tween to
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.moveX(gameObject.GetComponent<RectTransform>(), 200f, 1f).setDelay(1f);
*/
public static LTDescr moveX(RectTransform rectTrans, float to, float time){
return pushNewTween( rectTrans.gameObject, new Vector3(to,0f,0f), time, options().setCanvasMoveX().setRect( rectTrans ) );
}
/**
* Move a RectTransform object affecting y-axis only (used in Unity GUI in 4.6+, for Buttons, Panel, Scrollbar, etc...)
*
* @method LeanTween.moveY (RectTransform)
* @param {RectTransform} rectTrans:RectTransform RectTransform that you wish to attach the tween to
* @param {float} to:float The final y location with which to tween to
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.moveY(gameObject.GetComponent<RectTransform>(), 200f, 1f).setDelay(1f);
*/
public static LTDescr moveY(RectTransform rectTrans, float to, float time){
return pushNewTween( rectTrans.gameObject, new Vector3(to,0f,0f), time, options().setCanvasMoveY().setRect( rectTrans ) );
}
/**
* Move a RectTransform object affecting z-axis only (used in Unity GUI in 4.6+, for Buttons, Panel, Scrollbar, etc...)
*
* @method LeanTween.moveZ (RectTransform)
* @param {RectTransform} rectTrans:RectTransform RectTransform that you wish to attach the tween to
* @param {float} to:float The final x location with which to tween to
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.moveZ(gameObject.GetComponent<RectTransform>(), 200f, 1f).setDelay(1f);
*/
public static LTDescr moveZ(RectTransform rectTrans, float to, float time){
return pushNewTween( rectTrans.gameObject, new Vector3(to,0f,0f), time, options().setCanvasMoveZ().setRect( rectTrans ) );
}
/**
* Rotate a RectTransform object (used in Unity GUI in 4.6+, for Buttons, Panel, Scrollbar, etc...)
*
* @method LeanTween.rotate (RectTransform)
* @param {RectTransform} rectTrans:RectTransform RectTransform that you wish to attach the tween to
* @param {float} to:float The degree with which to rotate the RectTransform
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.rotate(gameObject.GetComponent<RectTransform>(), 90f, 1f).setDelay(1f);
*/
public static LTDescr rotate(RectTransform rectTrans, float to, float time){
return pushNewTween( rectTrans.gameObject, new Vector3(to,0f,0f), time, options().setCanvasRotateAround().setRect( rectTrans ).setAxis(Vector3.forward) );
}
public static LTDescr rotate(RectTransform rectTrans, Vector3 to, float time){
return pushNewTween( rectTrans.gameObject, to, time, options().setCanvasRotateAround().setRect( rectTrans ).setAxis(Vector3.forward) );
}
/**
* Rotate a RectTransform object (used in Unity GUI in 4.6+, for Buttons, Panel, Scrollbar, etc...)
*
* @method LeanTween.rotateAround (RectTransform)
* @param {RectTransform} rectTrans:RectTransform RectTransform that you wish to attach the tween to
* @param {Vector3} axis:Vector3 The axis in which to rotate the RectTransform (Vector3.forward is most commonly used)
* @param {float} to:float The degree with which to rotate the RectTransform
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.rotateAround(gameObject.GetComponent<RectTransform>(), Vector3.forward, 90f, 1f).setDelay(1f);
*/
public static LTDescr rotateAround(RectTransform rectTrans, Vector3 axis, float to, float time){
return pushNewTween( rectTrans.gameObject, new Vector3(to,0f,0f), time, options().setCanvasRotateAround().setRect( rectTrans ).setAxis(axis) );
}
/**
* Rotate a RectTransform object around it's local axis (used in Unity GUI in 4.6+, for Buttons, Panel, Scrollbar, etc...)
*
* @method LeanTween.rotateAroundLocal (RectTransform)
* @param {RectTransform} rectTrans:RectTransform RectTransform that you wish to attach the tween to
* @param {Vector3} axis:Vector3 The local axis in which to rotate the RectTransform (Vector3.forward is most commonly used)
* @param {float} to:float The degree with which to rotate the RectTransform
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.rotateAroundLocal(gameObject.GetComponent<RectTransform>(), Vector3.forward, 90f, 1f).setDelay(1f);
*/
public static LTDescr rotateAroundLocal(RectTransform rectTrans, Vector3 axis, float to, float time){
return pushNewTween( rectTrans.gameObject, new Vector3(to,0f,0f), time, options().setCanvasRotateAroundLocal().setRect( rectTrans ).setAxis(axis) );
}
/**
* Scale a RectTransform object (used in Unity GUI in 4.6+, for Buttons, Panel, Scrollbar, etc...)
*
* @method LeanTween.scale (RectTransform)
* @param {RectTransform} rectTrans:RectTransform RectTransform that you wish to attach the tween to
* @param {Vector3} to:Vector3 The final Vector3 with which to tween to (localScale)
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.scale(gameObject.GetComponent<RectTransform>(), gameObject.GetComponent<RectTransform>().localScale*2f, 1f).setDelay(1f);
*/
public static LTDescr scale(RectTransform rectTrans, Vector3 to, float time){
return pushNewTween( rectTrans.gameObject, to, time, options().setCanvasScale().setRect( rectTrans ) );
}
/**
* Change the sizeDelta of a RectTransform object (used in Unity Canvas, for Buttons, Panel, Scrollbar, etc...)
*
* @method LeanTween.size (RectTransform)
* @param {RectTransform} rectTrans:RectTransform RectTransform that you wish to attach the tween to
* @param {Vector2} to:Vector2 The final Vector2 the tween will end at for sizeDelta property
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.size(gameObject.GetComponent<RectTransform>(), gameObject.GetComponent<RectTransform>().sizeDelta*2f, 1f).setDelay(1f);
*/
public static LTDescr size(RectTransform rectTrans, Vector2 to, float time){
return pushNewTween( rectTrans.gameObject, to, time, options().setCanvasSizeDelta().setRect( rectTrans ) );
}
/**
* Alpha an Image Component attached to a RectTransform (used in Unity GUI in 4.6+, for Buttons, Panel, Scrollbar, etc...)
*
* @method LeanTween.alpha (RectTransform)
* @param {RectTransform} rectTrans:RectTransform RectTransform that you wish to attach the tween to
* @param {float} to:float The final Vector3 with which to tween to (localScale)
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.alpha(gameObject.GetComponent<RectTransform>(), 0.5f, 1f).setDelay(1f);
*/
public static LTDescr alpha(RectTransform rectTrans, float to, float time){
return pushNewTween( rectTrans.gameObject, new Vector3(to,0f,0f), time, options().setCanvasAlpha().setRect( rectTrans ) );
}
/**
* Change the Color of an Image Component attached to a RectTransform (used in Unity GUI in 4.6+, for Buttons, Panel, Scrollbar, etc...)
*
* @method LeanTween.alpha (RectTransform)
* @param {RectTransform} rectTrans:RectTransform RectTransform that you wish to attach the tween to
* @param {float} to:float The final Vector3 with which to tween to (localScale)
* @param {float} time:float The time to complete the tween in
* @return {LTDescr} LTDescr an object that distinguishes the tween
* @example LeanTween.color(gameObject.GetComponent<RectTransform>(), 0.5f, 1f).setDelay(1f);
*/
public static LTDescr color(RectTransform rectTrans, Color to, float time){
return pushNewTween( rectTrans.gameObject, new Vector3(1.0f, to.a, 0.0f), time, options().setCanvasColor().setRect( rectTrans ).setPoint( new Vector3(to.r, to.g, to.b) ) );
}
#endif
// Tweening Functions - Thanks to Robert Penner and GFX47
public static float tweenOnCurve( LTDescr tweenDescr, float ratioPassed ){
// Debug.Log("single ratio:"+ratioPassed+" tweenDescr.animationCurve.Evaluate(ratioPassed):"+tweenDescr.animationCurve.Evaluate(ratioPassed));
return tweenDescr.from.x + (tweenDescr.diff.x) * tweenDescr.optional.animationCurve.Evaluate(ratioPassed);
}
public static Vector3 tweenOnCurveVector( LTDescr tweenDescr, float ratioPassed ){
return new Vector3(tweenDescr.from.x + (tweenDescr.diff.x) * tweenDescr.optional.animationCurve.Evaluate(ratioPassed),
tweenDescr.from.y + (tweenDescr.diff.y) * tweenDescr.optional.animationCurve.Evaluate(ratioPassed),
tweenDescr.from.z + (tweenDescr.diff.z) * tweenDescr.optional.animationCurve.Evaluate(ratioPassed) );
}
public static float easeOutQuadOpt( float start, float diff, float ratioPassed ){
return -diff * ratioPassed * (ratioPassed - 2) + start;
}
public static float easeInQuadOpt( float start, float diff, float ratioPassed ){
return diff * ratioPassed * ratioPassed + start;
}
public static float easeInOutQuadOpt( float start, float diff, float ratioPassed ){
ratioPassed /= .5f;
if (ratioPassed < 1) return diff / 2 * ratioPassed * ratioPassed + start;
ratioPassed--;
return -diff / 2 * (ratioPassed * (ratioPassed - 2) - 1) + start;
}
public static Vector3 easeInOutQuadOpt( Vector3 start, Vector3 diff, float ratioPassed ){
ratioPassed /= .5f;
if (ratioPassed < 1) return diff / 2 * ratioPassed * ratioPassed + start;
ratioPassed--;
return -diff / 2 * (ratioPassed * (ratioPassed - 2) - 1) + start;
}
public static float linear(float start, float end, float val){
return Mathf.Lerp(start, end, val);
}
public static float clerp(float start, float end, float val){
float min = 0.0f;
float max = 360.0f;
float half = Mathf.Abs((max - min) / 2.0f);
float retval = 0.0f;
float diff = 0.0f;
if ((end - start) < -half){
diff = ((max - start) + end) * val;
retval = start + diff;
}else if ((end - start) > half){
diff = -((max - end) + start) * val;
retval = start + diff;
}else retval = start + (end - start) * val;
return retval;
}
public static float spring(float start, float end, float val ){
val = Mathf.Clamp01(val);
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 start + (end - start) * val;
}
public static float easeInQuad(float start, float end, float val){
end -= start;
return end * val * val + start;
}
public static float easeOutQuad(float start, float end, float val){
end -= start;
return -end * val * (val - 2) + start;
}
public static float easeInOutQuad(float start, float end, float val){
val /= .5f;
end -= start;
if (val < 1) return end / 2 * val * val + start;
val--;
return -end / 2 * (val * (val - 2) - 1) + start;
}
public static float easeInOutQuadOpt2(float start, float diffBy2, float val, float val2){
val /= .5f;
if (val < 1) return diffBy2 * val2 + start;
val--;
return -diffBy2 * ((val2 - 2) - 1f) + start;
}
public static float easeInCubic(float start, float end, float val){
end -= start;
return end * val * val * val + start;
}
public static float easeOutCubic(float start, float end, float val){
val--;
end -= start;
return end * (val * val * val + 1) + start;
}
public static float easeInOutCubic(float start, float end, float val){
val /= .5f;
end -= start;
if (val < 1) return end / 2 * val * val * val + start;
val -= 2;
return end / 2 * (val * val * val + 2) + start;
}
public static float easeInQuart(float start, float end, float val){
end -= start;
return end * val * val * val * val + start;
}
public static float easeOutQuart(float start, float end, float val){
val--;
end -= start;
return -end * (val * val * val * val - 1) + start;
}
public static float easeInOutQuart(float start, float end, float val){
val /= .5f;
end -= start;
if (val < 1) return end / 2 * val * val * val * val + start;
val -= 2;
return -end / 2 * (val * val * val * val - 2) + start;
}
public static float easeInQuint(float start, float end, float val){
end -= start;
return end * val * val * val * val * val + start;
}
public static float easeOutQuint(float start, float end, float val){
val--;
end -= start;
return end * (val * val * val * val * val + 1) + start;
}
public static float easeInOutQuint(float start, float end, float val){
val /= .5f;
end -= start;
if (val < 1) return end / 2 * val * val * val * val * val + start;
val -= 2;
return end / 2 * (val * val * val * val * val + 2) + start;
}
public static float easeInSine(float start, float end, float val){
end -= start;
return -end * Mathf.Cos(val / 1 * (Mathf.PI / 2)) + end + start;
}
public static float easeOutSine(float start, float end, float val){
end -= start;
return end * Mathf.Sin(val / 1 * (Mathf.PI / 2)) + start;
}
public static float easeInOutSine(float start, float end, float val){
end -= start;
return -end / 2 * (Mathf.Cos(Mathf.PI * val / 1) - 1) + start;
}
public static float easeInExpo(float start, float end, float val){
end -= start;
return end * Mathf.Pow(2, 10 * (val / 1 - 1)) + start;
}
public static float easeOutExpo(float start, float end, float val){
end -= start;
return end * (-Mathf.Pow(2, -10 * val / 1) + 1) + start;
}
public static float easeInOutExpo(float start, float end, float val){
val /= .5f;
end -= start;
if (val < 1) return end / 2 * Mathf.Pow(2, 10 * (val - 1)) + start;
val--;
return end / 2 * (-Mathf.Pow(2, -10 * val) + 2) + start;
}
public static float easeInCirc(float start, float end, float val){
end -= start;
return -end * (Mathf.Sqrt(1 - val * val) - 1) + start;
}
public static float easeOutCirc(float start, float end, float val){
val--;
end -= start;
return end * Mathf.Sqrt(1 - val * val) + start;
}
public static float easeInOutCirc(float start, float end, float val){
val /= .5f;
end -= start;
if (val < 1) return -end / 2 * (Mathf.Sqrt(1 - val * val) - 1) + start;
val -= 2;
return end / 2 * (Mathf.Sqrt(1 - val * val) + 1) + start;
}
public static float easeInBounce(float start, float end, float val){
end -= start;
float d = 1f;
return end - easeOutBounce(0, end, d-val) + start;
}
public static float easeOutBounce(float start, float end, float val){
val /= 1f;
end -= start;
if (val < (1 / 2.75f)){
return end * (7.5625f * val * val) + start;
}else if (val < (2 / 2.75f)){
val -= (1.5f / 2.75f);
return end * (7.5625f * (val) * val + .75f) + start;
}else if (val < (2.5 / 2.75)){
val -= (2.25f / 2.75f);
return end * (7.5625f * (val) * val + .9375f) + start;
}else{
val -= (2.625f / 2.75f);
return end * (7.5625f * (val) * val + .984375f) + start;
}
}
public static float easeInOutBounce(float start, float end, float val){
end -= start;
float d= 1f;
if (val < d/2) return easeInBounce(0, end, val*2) * 0.5f + start;
else return easeOutBounce(0, end, val*2-d) * 0.5f + end*0.5f + start;
}
public static float easeInBack(float start, float end, float val, float overshoot = 1.0f){
end -= start;
val /= 1;
float s= 1.70158f * overshoot;
return end * (val) * val * ((s + 1) * val - s) + start;
}
public static float easeOutBack(float start, float end, float val, float overshoot = 1.0f){
float s = 1.70158f * overshoot;
end -= start;
val = (val / 1) - 1;
return end * ((val) * val * ((s + 1) * val + s) + 1) + start;
}
public static float easeInOutBack(float start, float end, float val, float overshoot = 1.0f){
float s = 1.70158f * overshoot;
end -= start;
val /= .5f;
if ((val) < 1){
s *= (1.525f) * overshoot;
return end / 2 * (val * val * (((s) + 1) * val - s)) + start;
}
val -= 2;
s *= (1.525f) * overshoot;
return end / 2 * ((val) * val * (((s) + 1) * val + s) + 2) + start;
}
public static float easeInElastic(float start, float end, float val, float overshoot = 1.0f, float period = 0.3f){
end -= start;
float p = period;
float s = 0f;
float a = 0f;
if (val == 0f) return start;
if (val == 1f) return start + end;
if (a == 0f || a < Mathf.Abs(end)){
a = end;
s = p / 4f;
}else{
s = p / (2f * Mathf.PI) * Mathf.Asin(end / a);
}
if(overshoot>1f && val>0.6f )
overshoot = 1f + ((1f-val) / 0.4f * (overshoot-1f));
// Debug.Log("ease in elastic val:"+val+" a:"+a+" overshoot:"+overshoot);
val = val-1f;
return start-(a * Mathf.Pow(2f, 10f * val) * Mathf.Sin((val - s) * (2f * Mathf.PI) / p)) * overshoot;
}
public static float easeOutElastic(float start, float end, float val, float overshoot = 1.0f, float period = 0.3f){
end -= start;
float p = period;
float s = 0f;
float a = 0f;
if (val == 0f) return start;
// Debug.Log("ease out elastic val:"+val+" a:"+a);
if (val == 1f) return start + end;
if (a == 0f || a < Mathf.Abs(end)){
a = end;
s = p / 4f;
}else{
s = p / (2f * Mathf.PI) * Mathf.Asin(end / a);
}
if(overshoot>1f && val<0.4f )
overshoot = 1f + (val / 0.4f * (overshoot-1f));
// Debug.Log("ease out elastic val:"+val+" a:"+a+" overshoot:"+overshoot);
return start + end + a * Mathf.Pow(2f, -10f * val) * Mathf.Sin((val - s) * (2f * Mathf.PI) / p) * overshoot;
}
public static float easeInOutElastic(float start, float end, float val, float overshoot = 1.0f, float period = 0.3f)
{
end -= start;
float p = period;
float s = 0f;
float a = 0f;
if (val == 0f) return start;
val = val / (1f/2f);
if (val == 2f) return start + end;
if (a == 0f || a < Mathf.Abs(end)){
a = end;
s = p / 4f;
}else{
s = p / (2f * Mathf.PI) * Mathf.Asin(end / a);
}
if(overshoot>1f){
if( val<0.2f ){
overshoot = 1f + (val / 0.2f * (overshoot-1f));
}else if( val > 0.8f ){
overshoot = 1f + ((1f-val) / 0.2f * (overshoot-1f));
}
}
if (val < 1f){
val = val-1f;
return start - 0.5f * (a * Mathf.Pow(2f, 10f * val) * Mathf.Sin((val - s) * (2f * Mathf.PI) / p)) * overshoot;
}
val = val-1f;
return end + start + a * Mathf.Pow(2f, -10f * val) * Mathf.Sin((val - s) * (2f * Mathf.PI) / p) * 0.5f * overshoot;
}
// LeanTween Listening/Dispatch
private static System.Action[] eventListeners;
private static GameObject[] goListeners;
private static int eventsMaxSearch = 0;
public static int EVENTS_MAX = 10;
public static int LISTENERS_MAX = 10;
private static int INIT_LISTENERS_MAX = LISTENERS_MAX;
public static void addListener( int eventId, System.Action callback ){
addListener(tweenEmpty, eventId, callback);
}
/**
* Add a listener method to be called when the appropriate LeanTween.dispatchEvent is called
*
* @method LeanTween.addListener
* @param {GameObject} caller:GameObject the gameObject the listener is attached to
* @param {int} eventId:int a unique int that describes the event (best to use an enum)
* @param {System.Action} callback:System.Action the method to call when the event has been dispatched
* @example
* LeanTween.addListener(gameObject, (int)MyEvents.JUMP, jumpUp); callback ){
if(eventListeners==null){
INIT_LISTENERS_MAX = LISTENERS_MAX;
eventListeners = new System.Action[ EVENTS_MAX * LISTENERS_MAX ];
goListeners = new GameObject[ EVENTS_MAX * LISTENERS_MAX ];
}
// Debug.Log("searching for an empty space for:"+caller + " eventid:"+event);
for(i = 0; i < INIT_LISTENERS_MAX; i++){
int point = eventId*INIT_LISTENERS_MAX + i;
if(goListeners[ point ]==null || eventListeners[ point ]==null){
eventListeners[ point ] = callback;
goListeners[ point ] = caller;
if(i>=eventsMaxSearch)
eventsMaxSearch = i+1;
// Debug.Log("adding event for:"+caller.name);
return;
}
#if UNITY_FLASH
if(goListeners[ point ] == caller && System.Object.ReferenceEquals( eventListeners[ point ], callback)){
// Debug.Log("This event is already being listened for.");
return;
}
#else
if(goListeners[ point ] == caller && System.Object.Equals( eventListeners[ point ], callback)){
// Debug.Log("This event is already being listened for.");
return;
}
#endif
}
Debug.LogError("You ran out of areas to add listeners, consider increasing LISTENERS_MAX, ex: LeanTween.LISTENERS_MAX = "+(LISTENERS_MAX*2));
}
public static bool removeListener( int eventId, System.Action callback ){
return removeListener( tweenEmpty, eventId, callback);
}
/**
* Remove an event listener you have added
* @method LeanTween.removeListener
* @param {GameObject} caller:GameObject the gameObject the listener is attached to
* @param {int} eventId:int a unique int that describes the event (best to use an enum)
* @param {System.Action} callback:System.Action the method that was specified to call when the event has been dispatched
* @example
* LeanTween.removeListener(gameObject, (int)MyEvents.JUMP, jumpUp); callback ){
for(i = 0; i < eventsMaxSearch; i++){
int point = eventId*INIT_LISTENERS_MAX + i;
#if UNITY_FLASH
if(goListeners[ point ] == caller && System.Object.ReferenceEquals( eventListeners[ point ], callback) ){
#else
if(goListeners[ point ] == caller && System.Object.Equals( eventListeners[ point ], callback) ){
#endif
eventListeners[ point ] = null;
goListeners[ point ] = null;
return true;
}
}
return false;
}
/**
* Tell the added listeners that you are dispatching the event
* @method LeanTween.dispatchEvent
* @param {int} eventId:int a unique int that describes the event (best to use an enum)
* @example
* LeanTween.dispatchEvent( (int)MyEvents.JUMP );startPoint ,endControl,startControl,endPoint - Note: the control for the end and start are reversed! This is just a *quirk* of the API.Note: The first and last item just define the angle of the end points, they are not actually used in the spline path itself. If you do not care about the angle you can jus set the first two items and last two items as the same value.1f?1f:ratio;
return constantSpeed ? map(t) : interp(t);
}
public void place2d( Transform transform, float ratio ){
transform.position = point( ratio );
ratio += 0.001f;
if(ratio<=1.0f){
Vector3 v3Dir = point( ratio ) - transform.position;
float angle = Mathf.Atan2(v3Dir.y, v3Dir.x) * Mathf.Rad2Deg;
transform.eulerAngles = new Vector3(0, 0, angle);
}
}
public void placeLocal2d( Transform transform, float ratio ){
Transform trans = transform.parent;
if(trans==null){ // this has no parent, just do a regular transform
place2d(transform, ratio);
return;
}
transform.localPosition = point( ratio );
ratio += 0.001f;
if(ratio<=1.0f){
Vector3 ptAhead = point( ratio );//trans.TransformPoint( );
Vector3 v3Dir = ptAhead - transform.localPosition;
float angle = Mathf.Atan2(v3Dir.y, v3Dir.x) * Mathf.Rad2Deg;
transform.eulerAngles = new Vector3(0, 0, angle);
}
}
/**
* Place an object along a certain point on the path (facing the direction perpendicular to the path)
*
* @method place
* @param {Transform} transform:Transform the transform of the object you wish to place along the path
* @param {float} ratio:float ratio of the point along the path you wish to receive (0-1)
* @example
* ltPath.place( transform, 0.6f );
*/
public void place( Transform transform, float ratio ){
place(transform, ratio, Vector3.up);
}
/**
* Place an object along a certain point on the path, with it facing a certain direction perpendicular to the path
*
* @method place
* @param {Transform} transform:Transform the transform of the object you wish to place along the path
* @param {float} ratio:float ratio of the point along the path you wish to receive (0-1)
* @param {Vector3} rotation:Vector3 the direction in which to place the transform ex: Vector3.up
* @example
* ltPath.place( transform, 0.6f, Vector3.left );
*/
public void place( Transform transform, float ratio, Vector3 worldUp ){
// ratio = Mathf.Repeat(ratio, 1.0f); // make sure ratio is always between 0-1
transform.position = point( ratio );
ratio += 0.001f;
if(ratio<=1.0f)
transform.LookAt( point( ratio ), worldUp );
}
/**
* Place an object along a certain point on the path (facing the direction perpendicular to the path) - Local Space, not world-space
*
* @method placeLocal
* @param {Transform} transform:Transform the transform of the object you wish to place along the path
* @param {float} ratio:float ratio of the point along the path you wish to receive (0-1)
* @example
* ltPath.placeLocal( transform, 0.6f );
*/
public void placeLocal( Transform transform, float ratio ){
placeLocal( transform, ratio, Vector3.up );
}
/**
* Place an object along a certain point on the path, with it facing a certain direction perpendicular to the path - Local Space, not world-space
*
* @method placeLocal
* @param {Transform} transform:Transform the transform of the object you wish to place along the path
* @param {float} ratio:float ratio of the point along the path you wish to receive (0-1)
* @param {Vector3} rotation:Vector3 the direction in which to place the transform ex: Vector3.up
* @example
* ltPath.placeLocal( transform, 0.6f, Vector3.left );
*/
public void placeLocal( Transform transform, float ratio, Vector3 worldUp ){
transform.localPosition = point( ratio );
ratio += 0.001f;
if(ratio<=1.0f)
transform.LookAt( transform.parent.TransformPoint( point( ratio ) ), worldUp );
}
public void gizmoDraw(float t = -1.0f) {
if(ptsAdj==null || ptsAdj.Length<=0)
return;
Vector3 prevPt = ptsAdj[0];
for (int i = 0; i < ptsAdjLength; i++) {
Vector3 currPt2 = ptsAdj[i];
// Debug.Log("currPt2:"+currPt2);
//Gizmos.color = new Color(UnityEngine.Random.Range(0f,1f),UnityEngine.Random.Range(0f,1f),UnityEngine.Random.Range(0f,1f),1);
Gizmos.DrawLine(prevPt, currPt2);
prevPt = currPt2;
}
}
public void drawGizmo( Color color ) {
if( this.ptsAdjLength>=4){
Vector3 prevPt = this.ptsAdj[0];
Color colorBefore = Gizmos.color;
Gizmos.color = color;
for (int i = 0; i < this.ptsAdjLength; i++) {
Vector3 currPt2 = this.ptsAdj[i];
// Debug.Log("currPt2:"+currPt2);
Gizmos.DrawLine(prevPt, currPt2);
prevPt = currPt2;
}
Gizmos.color = colorBefore;
}
}
public static void drawGizmo(Transform[] arr, Color color) {
if(arr.Length>=4){
Vector3[] vec3s = new Vector3[arr.Length];
for(int i = 0; i < arr.Length; i++){
vec3s[i] = arr[i].position;
}
LTSpline spline = new LTSpline(vec3s);
Vector3 prevPt = spline.ptsAdj[0];
Color colorBefore = Gizmos.color;
Gizmos.color = color;
for (int i = 0; i < spline.ptsAdjLength; i++) {
Vector3 currPt2 = spline.ptsAdj[i];
// Debug.Log("currPt2:"+currPt2);
Gizmos.DrawLine(prevPt, currPt2);
prevPt = currPt2;
}
Gizmos.color = colorBefore;
}
}
public static void drawLine(Transform[] arr, float width, Color color) {
if(arr.Length>=4){
}
}
/*public Vector3 Velocity(float t) {
t = map( t );
int numSections = pts.Length - 3;
int currPt = Mathf.Min(Mathf.FloorToInt(t * (float) numSections), numSections - 1);
float u = t * (float) numSections - (float) currPt;
Vector3 a = pts[currPt];
Vector3 b = pts[currPt + 1];
Vector3 c = pts[currPt + 2];
Vector3 d = pts[currPt + 3];
return 1.5f * (-a + 3f * b - 3f * c + d) * (u * u)
+ (2f * a -5f * b + 4f * c - d) * u
+ .5f * c - .5f * a;
}*/
public void drawLinesGLLines(Material outlineMaterial, Color color, float width){
GL.PushMatrix();
outlineMaterial.SetPass(0);
GL.LoadPixelMatrix();
GL.Begin(GL.LINES);
GL.Color(color);
if (constantSpeed) {
if (this.ptsAdjLength >= 4) {
Vector3 prevPt = this.ptsAdj[0];
for (int i = 0; i < this.ptsAdjLength; i++) {
Vector3 currPt2 = this.ptsAdj[i];
GL.Vertex(prevPt);
GL.Vertex(currPt2);
prevPt = currPt2;
}
}
} else {
if (this.pts.Length >= 4) {
Vector3 prevPt = this.pts[0];
float split = 1f / ((float)this.pts.Length * 10f);
float iter = 0f;
while (iter < 1f) {
float at = iter / 1f;
Vector3 currPt2 = interp(at);
// Debug.Log("currPt2:"+currPt2);
GL.Vertex(prevPt);
GL.Vertex(currPt2);
prevPt = currPt2;
iter += split;
}
}
}
GL.End();
GL.PopMatrix();
}
public Vector3[] generateVectors(){
if (this.pts.Length >= 4) {
List meshPoints = new List();
Vector3 prevPt = this.pts[0];
meshPoints.Add(prevPt);
float split = 1f / ((float)this.pts.Length * 10f);
float iter = 0f;
while (iter < 1f) {
float at = iter / 1f;
Vector3 currPt2 = interp(at);
// Debug.Log("currPt2:"+currPt2);
// GL.Vertex(prevPt);
// GL.Vertex(currPt2);
meshPoints.Add(currPt2);
// prevPt = currPt2;
iter += split;
}
meshPoints.ToArray();
}
return null;
}
}
/**
* Animate GUI Elements by creating this object and passing the *.rect variable to the GUI methodExample Javascript: Example C#: