} //END CallEvent
//----------------------------------//
private void CallLoadSceneEvent()
//----------------------------------//
{
float backTweenSpeed = fadeToTweenSpeed;
float backDelay = fadeToDelay;
EaseCurve.EaseType backEaseType = fadeToEaseType;
if( differentValuesForFadeBack )
{
backTweenSpeed = fadeBackTweenSpeed;
backDelay = fadeBackDelay;
backEaseType = fadeBackEaseType;
}
if( loadSceneBy == LoadSceneOptions.Number )
{
SceneLoader.instance.LoadSceneWithFade( GoToSceneNumber, fadeColor, fadeToTweenSpeed, backTweenSpeed, fadeToDelay, backDelay, fadeToEaseType, backEaseType, shouldWePlaySFX, FadeToSFX, FadeBackSFX, shouldWeFadeMusic, musicAudioSource, fadeToVolume, onFadeToScene, onAsyncLoadScene, onFadeToAndAsyncLoadScene, onLoadScene, onFadeBackToScene );
}
else if( loadSceneBy == LoadSceneOptions.Name )
{
SceneLoader.instance.LoadSceneWithFade( GoToSceneName, fadeColor, fadeToTweenSpeed, backTweenSpeed, fadeToDelay, backDelay, fadeToEaseType, backEaseType, shouldWePlaySFX, FadeToSFX, FadeBackSFX, shouldWeFadeMusic, musicAudioSource, fadeToVolume, onFadeToScene, onAsyncLoadScene, onFadeToAndAsyncLoadScene, onLoadScene, onFadeBackToScene );
}
} //END CallLoadSceneEvent
} //END PlayAlpha
//------------------------------------//
public void PlayAlpha( float alpha, float tweenSpeed, float delay, EaseCurve.EaseType easeType, UnityEvent CallOnComplete )
//------------------------------------//
{
Stop();
BeginPlayingAlpha( alpha, tweenSpeed, delay, easeType );
} //END PlayAlpha
} //END GetDelay
//--------------------------------------------//
public void SetEaseType( EaseCurve.EaseType easeType, UITweener.TweenValue tweenValue )
//--------------------------------------------//
{
foreach( UITweener ui in tweeners )
{
ui.SetEaseType( easeType, tweenValue );
}
} //END SetEaseType
} //END LoadSceneWithFade
//---------------------------------------------//
private void _LoadSceneWithFade(Color fadeToColor, float fadeToTweenSpeed,
float fadeBackTweenSpeed, float fadeToDelay, float fadeBackDelay,
EaseCurve.EaseType fadeToEaseType, EaseCurve.EaseType fadeBackEaseType, bool shouldWePlaySFX, AudioClip fadeToSFX, AudioClip fadeBackSFX,
bool shouldWeFadeMusic, AudioSource musicAudioSource, float fadeMusicToVolume,
UnityEvent onFadeTo, UnityEvent onAsyncLoad, UnityEvent onFadeToAndAsyncLoad, UnityEvent onLoadScene, UnityEvent onFadeBack)
//--------------------------------------------//
{
this.fadeBackTweenSpeed = fadeBackTweenSpeed;
this.fadeBackDelay = fadeBackDelay;
this.fadeBackEaseType = fadeBackEaseType;
this.shouldWePlaySFX = shouldWePlaySFX;
this.shouldWeFadeMusic = shouldWeFadeMusic;
this.musicAudioSource = musicAudioSource;
if (musicAudioSource != null)
{
this.originalMusicVolume = musicAudioSource.volume;
}
this.fadeBackSFX = fadeBackSFX;
this.onFadeTo = onFadeTo;
this.onAsyncLoad = onAsyncLoad;
this.onFadeToAndAsyncLoad = onFadeToAndAsyncLoad;
this.onLoadScene = onLoadScene;
this.onFadeBack = onFadeBack;
if (this.shouldWeFadeMusic && musicAudioSource != null && musicAudioSource.clip != null)
{
AudioHelper.instance.Fade(musicAudioSource, fadeMusicToVolume, fadeToTweenSpeed, 0f);
}
if (shouldWePlaySFX && fadeToSFX != null)
{
AudioSource.PlayClipAtPoint(fadeToSFX, Camera.main.transform.position, 1f);
}
levelTransitionInProgress = true;
hasCalled_onAsyncLoad_Message = false;
hasCalled_onFadeToAndAyncLoad_Message = false;
hasCalled_onLoadScene = false;
loadComplete = false;
fadeToComplete = false;
//Begin the async level load
StartCoroutine("BeginAsyncLoad");
//Begin the fade to color
UnityEvent _event = new UnityEvent();
_event.AddListener(FadeToColorComplete);
ScreenFadeManager.instance.Show(fadeToColor, fadeToTweenSpeed, fadeToDelay, fadeToEaseType, _event);
} //END _LoadSceneWithFade
} //END Force
//---------------------------------------//
public void Show( Color fadeToColor, float fadeSpeed, float delay, EaseCurve.EaseType easeCurve, UnityEvent onCompleteFunction )
//---------------------------------------//
{
if( showDebug ) { Debug.Log( "ScreenFadeManager.cs Show( onComplete ) " + onCompleteFunction.ToString() ); }
if( uiColorTweenManager_ScreenFader != null )
{
uiColorTweenManager_ScreenFader.Play( UITweener.TweenValue.Show, fadeToColor, fadeSpeed, delay, easeCurve, onCompleteFunction );
}
} //END Show
} //END Show
//---------------------------------------//
public void Hide( float fadeSpeed, float delay, EaseCurve.EaseType easeCurve, UnityEvent onCompleteFunction )
//---------------------------------------//
{
if( showDebug ) { Debug.Log( "ScreenFadeManager.cs Hide( onComplete ) " + onCompleteFunction.ToString() ); }
if( uiColorTweenManager_ScreenFader != null )
{
uiColorTweenManager_ScreenFader.PlayAlpha( 0f, fadeSpeed, delay, easeCurve, onCompleteFunction );
}
} //END Hide
} //END PlayAlpha
//--------------------------------------------//
public void PlayAlpha( float alpha, float tweenSpeed, float delay, EaseCurve.EaseType easeCurve, UnityEvent onComplete )
//--------------------------------------------//
{
Stop();
SetOnAllCompleteMethod( null );
foreach( UIColorTweener ui in tweeners )
{
ui.PlayAlpha( alpha, tweenSpeed, delay, easeCurve, onComplete );
}
} //END PlayAlpha
} //END LoadSceneWithFade
//---------------------------------------------//
public void LoadSceneWithFade(string sceneName, Color fadeToColor, float fadeToTweenSpeed,
float fadeBackTweenSpeed, float fadeToDelay, float fadeBackDelay,
EaseCurve.EaseType fadeToEaseType, EaseCurve.EaseType fadeBackEaseType, bool shouldWePlaySFX, AudioClip fadeToSFX, AudioClip fadeBackSFX,
bool shouldWeFadeMusic, AudioSource musicAudioSource, float fadeMusicToVolume)
//--------------------------------------------//
{
this.sceneNumber = -99;
this.sceneName = sceneName;
_LoadSceneWithFade(fadeToColor, fadeToTweenSpeed,
fadeBackTweenSpeed, fadeToDelay, fadeBackDelay,
fadeToEaseType, fadeBackEaseType, shouldWePlaySFX, fadeToSFX, fadeBackSFX,
shouldWeFadeMusic, musicAudioSource, fadeMusicToVolume,
null, null, null, null, null);
} //END LoadSceneWithFade
} //END PlayAlpha
//------------------------------------//
private void BeginPlayingAlpha( float alpha, float tweenSpeed, float delay, EaseCurve.EaseType easeType )
//------------------------------------//
{
Color startColor = GetStartColor( rendererType );
Color endColor = GetColorFromRendererWithNewAlpha( alpha );
if( rendererType == bxrTweenColor.RendererType.Renderer ) { tween = Renderer.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
else if( rendererType == bxrTweenColor.RendererType.Image ) { tween = image.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
else if( rendererType == bxrTweenColor.RendererType.RawImage ) { tween = rawImage.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
else if( rendererType == bxrTweenColor.RendererType.SpriteRenderer ){ tween = spriteRenderer.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
else if( rendererType == bxrTweenColor.RendererType.Text ) { tween = text.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
else if( rendererType == bxrTweenColor.RendererType.Material ) { tween = material.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
else if( rendererType == bxrTweenColor.RendererType.CanvasGroup ) { tween = canvasGroup.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
} //END BeginPlayingAlpha
} //END GetTweenSpeed
//-------------------------//
public void SetEaseType( EaseCurve.EaseType easeCurve, TweenValue tweenValue )
//-------------------------//
{
if( tweenValue == TweenValue.Default ) { easeType_Default = easeCurve; }
else if( tweenValue == TweenValue.Hide ) { easeType_Hide = easeCurve; }
else if( tweenValue == TweenValue.Show ) { easeType_Show = easeCurve; }
else if( tweenValue == TweenValue.HoverEnter ) { easeType_HoverEnter = easeCurve; }
else if( tweenValue == TweenValue.HoverExit ) { easeType_HoverExit = easeCurve; }
else if( tweenValue == TweenValue.Pressed ) { easeType_Pressed = easeCurve; }
else if( tweenValue == TweenValue.Hold ) { easeType_Hold = easeCurve; }
else if( tweenValue == TweenValue.Enabled ) { easeType_Enabled = easeCurve; }
else if( tweenValue == TweenValue.Disabled ) { easeType_Disabled = easeCurve; }
} //END SetEaseType
} //END LoadSceneWithFade
//---------------------------------------------//
public void LoadSceneWithFade(int sceneNumber, Color fadeToColor, float fadeToTweenSpeed,
float fadeBackTweenSpeed, float fadeToDelay, float fadeBackDelay,
EaseCurve.EaseType fadeToEaseType, EaseCurve.EaseType fadeBackEaseType, bool shouldWePlaySFX, AudioClip fadeToSFX, AudioClip fadeBackSFX,
bool shouldWeFadeMusic, AudioSource musicAudioSource, float fadeMusicToVolume,
UnityEvent onFadeTo, UnityEvent onAsyncLoad, UnityEvent onFadeToAndAsyncLoad, UnityEvent onLoadScene, UnityEvent onFadeBack)
//--------------------------------------------//
{
this.sceneNumber = sceneNumber;
this.sceneName = "";
_LoadSceneWithFade(fadeToColor, fadeToTweenSpeed,
fadeBackTweenSpeed, fadeToDelay, fadeBackDelay,
fadeToEaseType, fadeBackEaseType, shouldWePlaySFX, fadeToSFX, fadeBackSFX,
shouldWeFadeMusic, musicAudioSource, fadeMusicToVolume,
onFadeTo, onAsyncLoad, onFadeToAndAsyncLoad, onLoadScene, onFadeBack);
} //END LoadSceneWithFade
} //END CallEvent
//-----------------------------//
private void CallChangeVRBackground()
//-----------------------------//
{
float backTweenSpeed = fadeToTweenSpeed;
float backDelay = fadeToDelay;
EaseCurve.EaseType backEaseType = fadeToEaseType;
if( differentValuesForFadeBack )
{
backTweenSpeed = fadeBackTweenSpeed;
backDelay = fadeBackDelay;
backEaseType = fadeBackEaseType;
}
XRSkyboxManager.instance.LoadImageWithFade( GoToImage, fadeColor, fadeToTweenSpeed, backTweenSpeed, fadeToDelay, backDelay, fadeToEaseType, backEaseType, shouldWePlaySFX, FadeToSFX, FadeBackSFX, shouldWeFadeMusic, musicAudioSource, fadeToVolume, onVRBackgroundFadeToColor, onVRBackgroundLoadImage, onVRBackgroundBlendToImage, onVRBackgroundFadeBackFromColor );
} //END CallChangeVRBackground
} //END Play
//------------------------------------//
protected override void CallTween( UITweener.TweenValue tweenValue )
//------------------------------------//
{
base.CallTween( tweenValue );
SetFinishScaleBasedOnMultiplier();
Vector3 startScale = GetStartScale();
Vector3 endScale = GetEndScale( tweenValue );
float tweenSpeed = GetTweenSpeed( tweenValue );
EaseCurve.EaseType easeType = GetEaseType( tweenValue );
float delay = GetDelay( tweenValue );
if( transformToScale != null )
{
tween = transformToScale.Scale( endScale, tweenSpeed, easeType, startScale, delay, false, onCompleteOrLoop );
}
} //END CallTween
} //END SetDelay
//--------------------------------------------//
public void SetEaseType( EaseCurve.EaseType easeType, UITweener.TweenValue tweenValue )
//--------------------------------------------//
{
foreach( UIColorTweenManager manager in colorTweenManagers )
{
manager.SetEaseType( easeType, tweenValue );
}
foreach( UIPositionTweenManager manager in positionTweenManagers )
{
manager.SetEaseType( easeType, tweenValue );
}
foreach( UIRotationTweenManager manager in rotationTweenManagers )
{
manager.SetEaseType( easeType, tweenValue );
}
foreach( UIScaleTweenManager manager in scaleTweenManagers )
{
manager.SetEaseType( easeType, tweenValue );
}
} //END SetEaseType
} //END Play
//------------------------------------//
protected override void CallTween( TweenValue tweenValue )
//------------------------------------//
{
base.CallTween( tweenValue );
Color startColor = GetStartColor( rendererType );
Color endColor = GetEndColor( tweenValue );
float tweenSpeed = GetTweenSpeed( tweenValue );
EaseCurve.EaseType easeType = GetEaseType( tweenValue );
float delay = GetDelay( tweenValue );
//Debug.Log( "UIColorTweener.cs CallTween( " + tweenValue + " ) object.name = " + name + ", Renderer = " + Renderer + ", Renderer.enabled = " + Renderer.enabled + ", rendererType = " + rendererType + ", endColor = " + endColor + ", onCompleteOrLoop = " + onCompleteOrLoop );
if( rendererType == bxrTweenColor.RendererType.Renderer ) { tween = Renderer.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
else if( rendererType == bxrTweenColor.RendererType.Image ) { tween = image.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
else if( rendererType == bxrTweenColor.RendererType.RawImage ) { tween = rawImage.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
else if( rendererType == bxrTweenColor.RendererType.SpriteRenderer ){ tween = spriteRenderer.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
else if( rendererType == bxrTweenColor.RendererType.Text ) { tween = text.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
else if( rendererType == bxrTweenColor.RendererType.Material ) { tween = material.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
else if( rendererType == bxrTweenColor.RendererType.CanvasGroup ) { tween = canvasGroup.Color( endColor, tweenSpeed, easeType, startColor, delay, false, onCompleteOrLoop ); }
} //END CallTween
} //END Play
//--------------------------------------------//
public void Play( UITweener.TweenValue tweenValue, Color color, float tweenSpeed, float delay, EaseCurve.EaseType easeCurve, UnityEvent onComplete )
//--------------------------------------------//
{
base.Play( tweenValue );
foreach( UIColorTweener ui in tweeners )
{
ui.Play( tweenValue, color, tweenSpeed, delay, easeCurve, onComplete );
}
} //END Play
} //END Play
//------------------------------------//
public void Play( TweenValue tweenValue, Color color, float tweenSpeed, float delay, EaseCurve.EaseType easeCurve, UnityEvent CallOnComplete )
//------------------------------------//
{
SetColor( color, tweenValue );
SetTweenSpeed( tweenSpeed, tweenValue );
SetDelay( delay, tweenValue );
SetEaseType( easeCurve, tweenValue );
SetOnCompleteEvent( CallOnComplete );
base.Play( tweenValue, CallOnComplete );
} //END Play
} //END Play
//--------------------------------------------//
public void Play( UITweener.TweenValue tweenValue, Vector3 scale, float tweenSpeed, float delay, EaseCurve.EaseType easeType, UnityEvent onComplete )
//--------------------------------------------//
{
Stop();
foreach( UIScaleTweener ui in tweeners )
{
ui.Play( tweenValue, scale, tweenSpeed, delay, easeType, onComplete );
}
} //END Play
} //END Play
//--------------------------------------------//
public void Play( UITweener.TweenValue tweenValue, Vector3 position, float tweenSpeed, float delay, EaseCurve.EaseType easeCurve, UnityEvent onComplete )
//--------------------------------------------//
{
base.Play( tweenValue );
foreach( UIPositionTweener ui in tweeners )
{
ui.Play( tweenValue, position, tweenSpeed, delay, easeCurve, onComplete );
}
} //END Play
} //END Force
//------------------------------------//
public void Play( TweenValue tweenValue, Vector3 rotation, float tweenSpeed, float delay, EaseCurve.EaseType easeCurve, UnityEvent CallOnComplete )
//------------------------------------//
{
SetRotation( rotation, tweenValue );
SetTweenSpeed( tweenSpeed, tweenValue );
SetDelay( delay, tweenValue );
SetEaseType( easeCurve, tweenValue );
base.Play( tweenValue, CallOnComplete );
} //END Play
} //END Rotate
//---------------------------------------------//
/// <summary>
/// Rotates a Transform or RectTransform using Quaternions. Supply this function with the localEulerAngles for the 'endValue' and 'startValue'
/// </summary>
/// <typeparam name="T">Transform</typeparam>
/// <param name="tweenThis">Accepts [Transform, RectTransform]</param>
/// <param name="endValue">What should the localEulerAngles for the transform be by the end of this rotation?</param>
/// <param name="length">How long tween should take</param>
/// <param name="easeType">What easing you would like to use</param>
/// <param name="startValue">[OPTIONAL] Value to start from. If not provided we will use the existing value from the 'tweenThis' object</param>
/// <param name="delay">[OPTIONAL] How long we should wait before starting to tween</param>
/// <param name="loop">[OPTIONAL] Keep the tween running via a loop indefinitely</param>
/// <param name="onCompleteOrLoop">[OPTIONAL] A UnityEvent to call once the tween has finished or completed a single loop</param>
/// <returns></returns>
public static bxrTween Rotate<T>( this T tweenThis, Vector3 endValue, float length, EaseCurve.EaseType easeType, Vector3? startValue = null, float delay = 0f, bool loop = false, UnityEvent onCompleteOrLoop = null ) where T : Transform
//---------------------------------------------//
{
return TweenManager.Rotate( tweenThis, endValue, length, EaseCurve.GetEaseCurve( easeType ), startValue, delay, loop, onCompleteOrLoop );
} //END Rotate
} //END Force
//------------------------------------//
public void Play( TweenValue tweenValue, Vector3 position, float tweenSpeed, float delay, EaseCurve.EaseType easeCurve, UnityEvent onCompleteOrLoop )
//------------------------------------//
{
SetPosition( position, tweenValue );
SetTweenSpeed( tweenSpeed, tweenValue );
SetDelay( delay, tweenValue );
SetEaseType( easeCurve, tweenValue );
base.Play( tweenValue, onCompleteOrLoop );
} //END Play
} //END Move
//------------------------------------------------------------------//
/// <summary>
/// Move a Transform across local or global space
/// </summary>
/// <typeparam name="T">Transform</typeparam>
/// <param name="tweenThis">Accepts [Transform, RectTransform]</param>
/// <param name="endValue">The position you would like to move this Transform to</param>
/// <param name="length">How long tween should take</param>
/// <param name="easeType">What easing you would like to use</param>
/// <param name="startValue">[OPTIONAL] Value to start from. If not provided we will use the existing value from the 'tweenThis' object</param>
/// <param name="useLocalOrWorldSpace">[OPTIONAL] Would you like this transform to move in local or global space?</param>
/// <param name="delay">[OPTIONAL] How long we should wait before starting to tween</param>
/// <param name="loop">[OPTIONAL] Keep the tween running via a loop indefinitely</param>
/// <param name="onCompleteOrLoop">[OPTIONAL] A UnityEvent to call once the tween has finished or completed a single loop</param>
/// <returns></returns>
public static bxrTween Move<T>( this T tweenThis, Vector3 endValue, float length, EaseCurve.EaseType easeType, Vector3? startValue = null, bxrTweenPosition.LocalOrWorldSpace useLocalOrWorldSpace = bxrTweenPosition.LocalOrWorldSpace.Local, float delay = 0f, bool loop = false, UnityEvent onCompleteOrLoop = null ) where T : Transform
//------------------------------------------------------------------//
{
return TweenManager.Move( tweenThis, endValue, length, EaseCurve.GetEaseCurve( easeType ), startValue, useLocalOrWorldSpace, delay, loop, onCompleteOrLoop );
} //END Move
} //END TweenFloat
//---------------------------------------------//
/// <summary>
/// Change any float value by passing in the UnityEngine Object and a fieldName
/// </summary>
/// <typeparam name="T">UnityEngine Object</typeparam>
/// <param name="tweenThis">The UnityEngine Object that will have it's value tweened</param>
/// <param name="fieldName">The variable ('field') we should tween</param>
/// <param name="endValue">Float value to tween to</param>
/// <param name="length">How long tween should take</param>
/// <param name="easeType">The easing you would like this tween to use</param>
/// <param name="startValue">[OPTIONAL] Value to start from. If not provided we will use the existing value from the 'tweenThis' object</param>
/// <param name="delay">[OPTIONAL] How long we should wait before starting to tween</param>
/// <param name="loop">[OPTIONAL] Keep the tween running via a loop indefinitely</param>
/// <param name="onCompleteOrLoop">[OPTIONAL] A UnityEvent to call once the tween has finished or completed a single loop</param>
/// <returns></returns>
public static bxrTween TweenFloat<T>( this T tweenThis, string fieldName, float endValue, float length, EaseCurve.EaseType easeType, float? startValue = null, float delay = 0f, bool loop = false, UnityEvent onCompleteOrLoop = null ) where T : UnityEngine.Object
//---------------------------------------------//
{
return TweenManager.TweenFloat( tweenThis, fieldName, endValue, length, EaseCurve.GetEaseCurve( easeType ), startValue, delay, loop, onCompleteOrLoop );
} //END TweenFloat
} //END AudioPitch
//---------------------------------------------//
/// <summary>
/// Change the pitch value for an AudioSource
/// </summary>
/// <param name="tweenThis">Accepts [AudioSource]</param>
/// <param name="endValue">What should the final pitch value be?</param>
/// <param name="length">How long tween should take</param>
/// <param name="easeType">The ease type you would like this tween to use</param>
/// <param name="startValue">[OPTIONAL] Value to start from. If not provided we will use the existing value from the 'tweenThis' object</param>
/// <param name="delay">[OPTIONAL] How long we should wait before starting to tween</param>
/// <param name="loop">[OPTIONAL] Keep the tween running via a loop indefinitely</param>
/// <param name="onCompleteOrLoop">[OPTIONAL] A UnityEvent to call once the tween has finished or completed a single loop</param>
/// <returns></returns>
public static bxrTween AudioPitch( this AudioSource tweenThis, float endValue, float length, EaseCurve.EaseType easeType, float? startValue = null, float delay = 0f, bool loop = false, UnityEvent onCompleteOrLoop = null )
//---------------------------------------------//
{
return TweenManager.TweenFloat( tweenThis, "pitch", endValue, length, EaseCurve.GetEaseCurve( easeType ), startValue, delay, loop, onCompleteOrLoop );
} //END AudioPitch
} //END ImageFill
//---------------------------------------------//
/// <summary>
/// Change the fill value for an Image object
/// </summary>
/// <param name="tweenThis">Accepts [Image]</param>
/// <param name="endValue">What should the final fill value be?</param>
/// <param name="length">How long tween should take</param>
/// <param name="easeType">What ease you would like this tween to use</param>
/// <param name="startValue">[OPTIONAL] Value to start from. If not provided we will use the existing value from the 'tweenThis' object</param>
/// <param name="delay">[OPTIONAL] How long we should wait before starting to tween</param>
/// <param name="loop">[OPTIONAL] Keep the tween running via a loop indefinitely</param>
/// <param name="onCompleteOrLoop">[OPTIONAL] A UnityEvent to call once the tween has finished or completed a single loop</param>
/// <returns></returns>
public static bxrTween ImageFill( this Image tweenThis, float endValue, float length, EaseCurve.EaseType easeType, float? startValue = null, float delay = 0f, bool loop = false, UnityEvent onCompleteOrLoop = null )
//---------------------------------------------//
{
return TweenManager.TweenFloat( tweenThis, "fillAmount", endValue, length, EaseCurve.GetEaseCurve( easeType ), startValue, delay, loop, onCompleteOrLoop );
} //END ImageFill
} //END Color
//---------------------------------------------//
/// <summary>
/// Change the color for the passed in Renderer or Material
/// </summary>
/// <typeparam name="T">Renderer/Object</typeparam>
/// <param name="tweenThis">Accepts [Renderer, Image, RawImage, SpriteRenderer, Text, Material, CanvasGroup]</param>
/// <param name="endValue">Color to tween to</param>
/// <param name="length">How long tween should take</param>
/// <param name="easeType">What ease type you would like this tween to use</param>
/// <param name="startValue">[OPTIONAL] Value to start from. If not provided we will use the existing value from the 'tweenThis' object</param>
/// <param name="delay">[OPTIONAL] How long we should wait before starting to tween</param>
/// <param name="loop">[OPTIONAL] Keep the tween running via a loop indefinitely</param>
/// <param name="onCompleteOrLoop">[OPTIONAL] A UnityEvent to call once the tween has finished or completed a single loop</param>
/// <returns></returns>
public static bxrTween Color<T>( this T tweenThis, Color endValue, float length, EaseCurve.EaseType easeType, Color? startValue = null, float delay = 0f, bool loop = false, UnityEvent onCompleteOrLoop = null )
//---------------------------------------------//
{
return TweenManager.Color( tweenThis, endValue, length, EaseCurve.GetEaseCurve( easeType ), startValue, delay, loop, onCompleteOrLoop );
} //END Color
