public void Fade(FadeType _fadeType, float _fadeTime, float startAlpha = -1)
{
StopCoroutine ("DoFade");
float currentAlpha = spriteRenderer.color.a;
if (startAlpha >= 0)
{
currentAlpha = startAlpha;
SetAlpha (startAlpha);
}
if (_fadeType == FadeType.fadeOut)
{
fadeStartTime = Time.time - (currentAlpha * _fadeTime);
}
else
{
fadeStartTime = Time.time - ((1f - currentAlpha) * _fadeTime);
}
fadeTime = _fadeTime;
fadeType = _fadeType;
StartCoroutine ("DoFade");
}
/// <summary>
/// Initializes a new instance of the <see cref="NotifyWindow"/> class.
/// Displays an empty notification.
/// </summary>
public NotifyWindow()
{
InitializeComponent();
numPixelsFade = Settings.Default.NotificationFadePixels;
fadeType = (FadeType) Settings.Default.NotificationFadeType;
}
private FadeType type; // Fade in or fade out.
#endregion Fields
#region Constructors
//-----------------------------------------------------------------------------
// Constructors
//-----------------------------------------------------------------------------
public StateScreenFade(Color color, float duration, FadeType type)
: base()
{
this.color = color;
this.duration = duration;
this.type = type;
}
public UiAnimationFade(GameObject gameobject, float duration, FadeType fadeType) : base(gameobject)
{
Canvas = gameobject.GetOrAddComponent<CanvasGroup>();
Canvas.alpha = fadeType == FadeType.In ? 0f : Canvas.alpha;
Duration = duration;
Fade = fadeType;
}
//-----------------------------------------------------------------------------
// Constructors
//-----------------------------------------------------------------------------
public TransitionFade(Color color, int duration, FadeType type, GameState gameState)
{
this.duration = duration;
this.timer = 0;
this.type = type;
this.color = color;
this.gameState = gameState;
}
void DrawCameraFlashButton()
{
if ( GUILayout.Button( "Flash/Lightning" ) ) {
fadeDirection = false;
currentFadeType = FadeType.Flash;
ScreenFade.Fade( Color.white, 1, 0, .5f, 0, true );
PlaySound( cameraShutterSound, 0 );
}
}
public StopSettings(bool onBeat, Metronome metronome, SnapStyle snapStyle, float beat, float delay, float fadeLength, FadeType fadeType, float power)
{
this.onBeat = onBeat;
this.metronome = metronome;
this.snapStyle = snapStyle;
this.beat = beat;
this.delay = delay;
this.fadeLength = fadeLength;
this.fadeType = fadeType;
this.power = power;
}
public void ImitateTrail(SplineTrailRenderer trail)
{
emit = trail.emit;
emissionDistance = trail.emissionDistance;
height = trail.height;
width = trail.width;
vertexColor = trail.vertexColor;
normal = trail.normal;
meshDisposition = trail.meshDisposition;
fadeType = trail.fadeType;
fadeLengthBegin = trail.fadeLengthBegin;
fadeLengthEnd = trail.fadeLengthEnd;
maxLength = trail.maxLength;
debugDrawSpline = trail.debugDrawSpline;
GetComponent<Renderer> ().material = trail.GetComponent<Renderer> ().material;
}
/**
* <summary>Fades the Sprite attached to this GameObject in or out.</summary>
* <param name = "_fadeType">The direction of the fade effect (fadeIn, fadeOut)</param>
* <param name = "_fadeTime">The duration, in seconds, of the fade effect</param>
* <param name = "startAlpha">The alpha value that the Sprite should have when the effect begins. If <0, the Sprite's original alpha will be used.</param>
*/
public void Fade(FadeType _fadeType, float _fadeTime, float startAlpha = -1)
{
StopCoroutine ("DoFade");
float currentAlpha = spriteRenderer.color.a;
if (startAlpha >= 0)
{
currentAlpha = startAlpha;
SetAlpha (startAlpha);
}
else
{
if (spriteRenderer.enabled == false)
{
spriteRenderer.enabled = true;
if (_fadeType == FadeType.fadeIn)
{
currentAlpha = 0f;
SetAlpha (0f);
}
}
}
if (_fadeType == FadeType.fadeOut)
{
fadeStartTime = Time.time - (currentAlpha * _fadeTime);
}
else
{
fadeStartTime = Time.time - ((1f - currentAlpha) * _fadeTime);
}
fadeTime = _fadeTime;
fadeType = _fadeType;
if (fadeTime > 0f)
{
StartCoroutine ("DoFade");
}
else
{
EndFade ();
}
}
//-----------------------------------------------------------------------------
// Private Methods
//-----------------------------------------------------------------------------
void DrawFadeButton()
{
//decide text to display on the button based on state of fadeDirection:
string fadeText = fadeDirection ? "down" : "up";
if ( GUILayout.Button( "Fade " + fadeText ) ) {
//set type of fadeDirection:
currentFadeType = FadeType.Fade;
//toggle state of fadeDirection:
fadeDirection = !fadeDirection;
//fade up or down based on state of fadeDirection:
if (fadeDirection) {
ScreenFade.Fade( Color.black, ScreenFade.CurrentAlpha, 1, 1, 0, false );
}else{
ScreenFade.Fade( Color.black, ScreenFade.CurrentAlpha, 0, 1, 0, false );
}
}
}
public void SetFadeLevel(FadeType type, float val)
{
switch (this.m_FadeType)
{
case FadeType.Vis:
this.m_FadeLevel1[0] = val;
return;
case FadeType.Sound:
this.m_FadeLevel1[1] = val;
return;
case FadeType.All:
this.m_FadeLevel1[0] = val;
this.m_FadeLevel1[1] = val;
return;
default:
return;
}
}
private IEnumerator FadeImage <T>(T target, FadeType fadeType, float duration) where T : Graphic
{
if (target == null)
{
yield break;
}
float startAlpha = fadeType == FadeType.FadeIn ? 0 : 1;
target.color = new Color(0, 0, 0, startAlpha);
var finalColor = new Color(0, 0, 0, startAlpha >= 0 ? 0 : 1);
for (var t = 0.0f; t < 1.0f; t += Time.unscaledDeltaTime / duration)
{
target.color = new Color(finalColor.r, finalColor.g, finalColor.b, Mathf.SmoothStep(startAlpha, finalColor.a, t));
yield return(null);
}
target.raycastTarget = fadeType != FadeType.FadeOut;
Destroy(target.gameObject);
}
// Update is called once per frame
private void FixedUpdate()
{
if (fadeType == FadeType.FADE_IN) // ! fade in sprite
{
GetComponent <SpriteRenderer>().color = new Color(color().r, color().g, color().b, color().a + (1.0f / fadeAwayFrames));
if (color().a >= 1 - (1.0f / fadeAwayFrames))
{
fadeType = FadeType.FADE_OUT;
} // ! when fully opaque : fade out
}
else if (fadeType == FadeType.FADE_OUT) // ! fade out and shrink
{
GetComponent <SpriteRenderer>().color = new Color(color().r, color().g, color().b, color().a - (1.0f / fadeAwayFrames));
Vector3 imageScale = transform.localScale;
transform.localScale = new Vector3(imageScale.x - 0.01f, imageScale.y - 0.01f, 1.0f);
if (color().a <= 0 + (1.0f / fadeAwayFrames)) // ! when faded out remove death image
{
Destroy(gameObject);
}
}
}
public static FadeType Opposite(this FadeType type)
{
if (type == FadeType.Fast)
{
return(FadeType.Slow);
}
if (type == FadeType.Slow)
{
return(FadeType.Fast);
}
if (type == FadeType.Hold)
{
return(FadeType.Release);
}
if (type == FadeType.Release)
{
return(FadeType.Hold);
}
return(type);
}
public void FadeOut(float _timeToFade)
{
AssignFadeTexture();
if (alpha == 0f)
{
alpha = 0.01f;
}
if (_timeToFade > 0f)
{
alpha = Mathf.Clamp01(alpha);
timeToFade = _timeToFade;
fadeType = FadeType.fadeOut;
fadeStartTime = Time.time - (alpha * timeToFade);
}
else
{
alpha = 1f;
timeToFade = 0f;
}
}
/// <summary>
/// Fades the music.
/// </summary>
/// <returns>The music.</returns>
/// <param name="aFadeType">A fade type.</param>
public IEnumerator FadeMusic(FadeType aFadeType)
{
//Here we make sure that we have access to the globalData file, this way we can referance the saved music volume,
// if we do not have a reference, just set the volume to the default sound volume
float currentSoundLevel = (aFadeType == FadeManager.FadeType.FadeIn)
? ((DataManager.globalData != null)
? DataManager.globalData.MusicVolume : WorldConstants.DEFAULT_MUSIC_V)
: SoundManager.Instance.musicSource.volume;
float _soundValue = (aFadeType == FadeType.FadeIn) ? 0.0f : 1.0f;
while (((aFadeType == FadeType.FadeIn) ? (_soundValue < 1.0f) : (_soundValue > 0.0f)))
{
_soundValue += ((aFadeType == FadeType.FadeIn) ? 1 : -1) * (1 * (float)fadeTransitionSpeed / 100.0f) * Time.deltaTime;
SoundManager.Instance.musicSource.volume = currentSoundLevel * _soundValue;
yield return(null);
}
//Once completed exit coroutine
yield return(null);
}
public static IEnumerator FadeGroup(Graphic[] objs, FadeType fade, float duration, float mult = 1)
{
for (float i = 0; i <= duration; i += Time.unscaledDeltaTime)
{
for (int j = 0; j < objs.Length; j++)
{
if (objs[j] != null)
{
objs[j].color = new Color(objs[j].color.r, objs[j].color.g, objs[j].color.b, Mathf.Abs(((int)fade) - (i / duration)) * mult);
}
}
yield return(null);
}
for (int j = 0; j < objs.Length; j++)
{
if (objs[j] != null)
{
objs[j].color = new Color(objs[j].color.r, objs[j].color.g, objs[j].color.b, (1 - Mathf.Abs(((int)fade)) * mult));
}
}
}
static List <double> _KeyframeTimes(FadeType type, double duration)
{
switch (type)
{
case FadeType.FadeIn:
return(new List <double>()
{
0, duration / 6, duration
});
case FadeType.FadeOut:
return(new List <double>()
{
0, duration / 6, duration
});
}
return(new List <double>()
{
0, duration / 6, duration
});
}
/// <summary>
/// Generates linear fade in and/or fade out effect for specified signal
/// </summary>
/// <param name="signal">Source signal</param>
/// <param name="fadePart">a part of signal to fade in [0..1], where 1 - full signal length</param>
/// <param name="fadeType"></param>
public static void LinearFade(ref double[] signal, double fadePart, FadeType fadeType)
{
int fadeLength = (int)(signal.Length * fadePart);
double delta = 1.0 / fadeLength;
bool isFadeIn = ((fadeType & FadeType.fadeIn) == FadeType.fadeIn);
bool isFadeOut = ((fadeType & FadeType.fadeOut) == FadeType.fadeOut);
for (int i = 0; i < fadeLength; i++)
{
if (isFadeIn)
{
signal[i] = (short)(signal[i] * delta * i);
}
if (isFadeOut)
{
signal[signal.Length - i - 1] = (short)(signal[signal.Length - i - 1] * delta * i);
}
}
}
IEnumerator FadePageImage(FadeType _fadeType)
{
previousButton.interactable = false;
nextButton.interactable = false;
audioHistoryButton.interactable = false;
//Fade out page image
if (currentPage.pageAnimator != null)
{
currentPage.pageAnimator.SetTrigger(fadeOut);
yield return(new WaitForSeconds(currentPage.pageAnimator.GetCurrentAnimatorStateInfo(0).length));
}
currentPage.pageImage.SetActive(false);
if (_fadeType == FadeType.PreviousPage && PageIndex > 0)
{
PageIndex--;
ValidatePageIndex();
}
else if (_fadeType == FadeType.NextPage)
{
PageIndex++;
ValidatePageIndex();
}
try
{
currentPage = pageList[PageIndex];
currentPage.pageImage.SetActive(true);
}
catch
{
yield break;
}
yield return(new WaitForSeconds(currentPage.pageAnimator.GetCurrentAnimatorStateInfo(0).length));
PlayCurrentPageAudio();
}
//// Fade in the GUITexture, wait a couple of seconds, then fade it out
//public void Start () {
// yield FadeGUITexture(guiObject, fadeTime, FadeType.In);
// yield WaitForSeconds(2.0);
// yield FadeGUITexture(guiObject, fadeTime, FadeType.Out);
// Application.LoadLevel (Application.loadedLevel+1);
// }
public static IEnumerator FadeGUITexture(this Texture2D texture, float seconds, FadeType fadeType)
{
float start = (float)(fadeType == FadeType.In ? 0.0 : 1.0);
float end = (float)(fadeType == FadeType.In ? 1.0 : 0.0);
float i = 0.0f;
float step = 1.0f / seconds;
while (i < 1.0)
{
i += step * Time.deltaTime;
Color[] newColors = new Color[texture.GetPixels().Length];
int x = 0;
foreach (Color color in texture.GetPixels())
{
newColors[x] = new Color(color.r, color.g, color.b, Mathf.Lerp(start, end, i) * .5f);
}
texture.SetPixels(newColors);
texture.Apply();
yield return(null);
}
}
public static IEnumerator FadeSceneOut(FadeType fadeType)
{
CanvasGroup canvasGroup;
switch (fadeType)
{
case FadeType.Win:
canvasGroup = _instance.winCanvasGroup;
break;
case FadeType.Death:
canvasGroup = _instance.deathCanvasGroup;
break;
default:
canvasGroup = _instance.menuCanvasGroup;
break;
}
canvasGroup.gameObject.SetActive(true);
yield return(_instance.StartCoroutine(_instance.Fade(1f, canvasGroup)));
}
public void FadeOut(FadeType type, float duration = 1.5f)
{
this.m_FadeDuration = duration;
Debug.Log(string.Concat(new string[]
{
"FadeSystem FadOut m_FadeIn = ",
this.m_FadeIn.ToString(),
" m_FadeOut = ",
this.m_FadeOut.ToString(),
" m_FadingIn ",
this.m_FadingIn.ToString(),
" m_FadingOut ",
this.m_FadingOut.ToString()
}));
this.m_FadeType = type;
this.m_FadeOut = true;
this.m_FadeIn = false;
this.m_FadingIn = false;
this.m_FadeLevel1[0] = 0f;
this.m_FadeLevel1[1] = 0f;
this.m_Active = true;
}
// Update is called once per frame
void Update()
{
if (fadeType == FadeType.FadeOut)
{
alpha_prm += Time.deltaTime * 1.2f;
if (alpha_prm >= fadeSpeed)
{
fadeType = FadeType.FadeNone;
}
SetAlpha(Mathf.Min(alpha_prm / fadeSpeed));
}
if (fadeType == FadeType.FadeIn)
{
alpha_prm -= Time.deltaTime;
if (alpha_prm <= 0)
{
fadeType = FadeType.FadeNone;
renderer1.enabled = false;
}
SetAlpha(Mathf.Max(0, alpha_prm / fadeSpeed));
}
}
//
public void StartFade(FadeType fadeType, float timeMS, bool destroyAtEnd)
{
if (fadeType == FadeType.FadeIn)
{
m_fadeOpacity = m_opacity;
m_fadeSign = -1;
}
else
{
m_fadeOpacity = 0;
m_fadeSign = 1;
}
m_fadeTimerMS = new Timer(Engine.RealTime.Source, timeMS);
if (destroyAtEnd)
{
m_fadeTimerMS.OnTime += m_fadeTimer_OnTime;
}
m_fadeTimerMS.Start();
}
public static void Play(string _title)
{
if (!Controller)
{
return;
}
if (CurrentTitle == _title)
{
return;
}
BGM.Stop();
Fade = FadeType.NONE;
if (Loops.ContainsKey(_title))
{
LoopStats = Loops[_title];
}
BGM.volume = MaxBGMVolume;
BGM.clip = (AudioClip)Resources.Load("BGM/" + _title);
BGM.timeSamples = 0;
BGM.Play();
CurrentTitle = _title;
}
// Update is called once per frame
void Update()
{
/*
* if( vrFade != null )
* {
* return ;
* }
*/
bool bFinish = false;
switch (fadeType)
{
case FadeType.FADE_IN:
bFinish = FadeIn();
break;
case FadeType.FADE_OUT:
bFinish = FadeOut();
break;
}
// フェードカウンター
if (IsFade())
{
counter += GameDefine.FPSDeltaScale();
if ((int)counter > FadeTime)
{
counter = FadeTime;
if (bFinish)
{
Debug.Log("Fade" + fadeType + "Is Finish");
fadeType = FadeType.FADE_NONE;
counter = 0.0f;
}
}
}
}
override public void ShowGUI()
{
fadeType = (FadeType)EditorGUILayout.EnumPopup("Type:", fadeType);
if (fadeType == FadeType.fadeOut)
{
setTexture = EditorGUILayout.Toggle("Custom fade texture?", setTexture);
if (setTexture)
{
tempTexture = (Texture2D)EditorGUILayout.ObjectField("Fade texture:", tempTexture, typeof(Texture2D), false);
}
}
isInstant = EditorGUILayout.Toggle("Instant?", isInstant);
if (!isInstant)
{
fadeSpeed = EditorGUILayout.Slider("Time to fade:", fadeSpeed, 0, 3);
willWait = EditorGUILayout.Toggle("Wait until finish?", willWait);
}
AfterRunningOption();
}
// Update is called once per frame
void Update()
{
if (fadeType_ == FadeType.FT_FadeIn)
{
progress += Time.deltaTime;
if (progress >= 1f)
{
if (isPlaying_)
{
EnterSenseMode();
}
else
{
QuitSenseMode();
}
fadeType_ = FadeType.FT_FadeOut;
progress = 1f;
}
}
else if (fadeType_ == FadeType.FT_FadeOut)
{
progress -= Time.deltaTime;
if (progress <= 0f)
{
if (isPlaying_ == false)
{
ProcEventForGuide();
}
progress = 0f;
fadeType_ = FadeType.FT_None;
ApplicationEntry.Instance.switchSceneMask_.SetActive(false);
}
}
else
{
progress = 0f;
}
}
public override void ShowGUI(List <ActionParameter> parameters)
{
fadeType = (FadeType)EditorGUILayout.EnumPopup("Type:", fadeType);
if (fadeType == FadeType.fadeOut)
{
setTexture = EditorGUILayout.Toggle("Custom fade texture?", setTexture);
if (setTexture)
{
tempTextureParameterID = Action.ChooseParameterGUI("Fade texture:", parameters, tempTextureParameterID, ParameterType.UnityObject);
if (tempTextureParameterID < 0)
{
tempTexture = (Texture2D)EditorGUILayout.ObjectField("Fade texture:", tempTexture, typeof(Texture2D), false);
}
}
}
isInstant = EditorGUILayout.Toggle("Instant?", isInstant);
if (!isInstant)
{
fadeSpeedParameterID = Action.ChooseParameterGUI("Time to fade (s):", parameters, fadeSpeedParameterID, ParameterType.Float);
if (fadeSpeedParameterID < 0)
{
fadeSpeed = EditorGUILayout.Slider("Time to fade (s):", fadeSpeed, 0f, 10f);
}
forceCompleteTransition = EditorGUILayout.Toggle("Force complete transition?", forceCompleteTransition);
if (forceCompleteTransition)
{
fadeCurve = (AnimationCurve)EditorGUILayout.CurveField("Transition curve:", fadeCurve);
}
willWait = EditorGUILayout.Toggle("Wait until finish?", willWait);
}
cameraFadePauseBehaviour = (CameraFadePauseBehaviour)EditorGUILayout.EnumPopup("Behaviour when paused:", cameraFadePauseBehaviour);
AfterRunningOption();
}
public static void CrossFadeBGM(string _title)
{
if (!Controller)
{
return;
}
if (CurrentTitle == _title)
{
return;
}
AudioClip c = (AudioClip)Resources.Load("BGM/" + _title);
if (c != null)
{
CurrentTitle = _title;
LoopStats = Loops[_title];
Fade = FadeType.FADEINOUT;
Crossfade.Stop();
Crossfade.clip = c;
Crossfade.volume = 0;
Crossfade.Play();
}
}
public static void Update()
{
if (sCurrentAction == FadeType.In)
{
sFadeAmt -= (Globals.System.GetTimeMs() - sLastUpdate) / sFadeRate * 255f;
if (sFadeAmt <= 0f)
{
sCurrentAction = FadeType.None;
sFadeAmt = 0f;
}
}
else if (sCurrentAction == FadeType.Out)
{
sFadeAmt += (Globals.System.GetTimeMs() - sLastUpdate) / sFadeRate * 255f;
if (sFadeAmt >= 255f)
{
sCurrentAction = FadeType.None;
sFadeAmt = 255f;
}
}
sLastUpdate = Globals.System.GetTimeMs();
}
private IEnumerator DoTheFadingAndTheQuitting(FadeType texture = FadeType.BLACK, bool slowMo = true)
{
if (slowMo)
{
//slowmotion
fadeSpeed *= 0.1f;
}
//does the fading
yield return(new WaitForSeconds(BeginFade(1, texture)));
//and also the quitting
#if UNITY_WEBGL || UNITY_EDITOR
if (slowMo)
{
fadeSpeed *= 10; //undo slowmo if it was enabled
}
SceneManager.LoadScene(0);
#else
Time.timeScale = 0;
Application.Quit(0);
#endif
}
public void SetFadeType(FadeType f)
{
fadeType = f;
switch (f)
{
case FadeType.FADEIN:
isFadeInFinished = false;
isFadeOutFinished = false;
fadeInTime = 0.0f;
fadeOutTime = 0.0f;
break;
case FadeType.FADEOUT:
isFadeInFinished = false;
isFadeOutFinished = false;
fadeInTime = 0.0f;
fadeOutTime = 0.0f;
break;
default:
break;
}
}
//Corutina estatica FadeOut, el mimso se pasa su propio parametro fadeType, interesnate...
public static IEnumerator FadeSceneOut(FadeType fadeType = FadeType.Black)
{ //.Black y .Gameover es llamado desde playerChar.. cuadndo muere
CanvasGroup canvasGroup;
switch (fadeType)
{
case FadeType.Black:
canvasGroup = Instance.faderCanvasGroup;
break;
case FadeType.GameOver:
canvasGroup = Instance.gameOverCanvasGroup;
break;
default:
canvasGroup = Instance.loadingCanvasGroup;
break;
}
canvasGroup.gameObject.SetActive(true);
//Usa dos veces Instance por que esta anidando corutinas la primera para ejecutar StartCoroutine dentro de FadeScen..estitco y Fade que no es estatico
yield return(Instance.StartCoroutine(Instance.Fade(1f, canvasGroup)));
}
override public void ShowGUI(List <ActionParameter> parameters)
{
parameterID = Action.ChooseParameterGUI("Sprite to fade:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
spriteFader = null;
}
else
{
spriteFader = (SpriteFader)EditorGUILayout.ObjectField("Sprite to fade:", spriteFader, typeof(SpriteFader), true);
constantID = FieldToID <SpriteFader> (spriteFader, constantID);
spriteFader = IDToField <SpriteFader> (spriteFader, constantID, false);
}
fadeType = (FadeType)EditorGUILayout.EnumPopup("Type:", fadeType);
fadeSpeed = EditorGUILayout.Slider("Time to fade:", fadeSpeed, 0f, 10f);
willWait = EditorGUILayout.Toggle("Wait until finish?", willWait);
AfterRunningOption();
}
public static IEnumerator FadeSceneOut(FadeType fadeType = FadeType.Black)
{
CanvasGroup canvasGroup;
switch (fadeType)
{
case FadeType.Black:
canvasGroup = Instance.faderCanvasGroup;
break;
case FadeType.GameOver:
canvasGroup = Instance.gameOverCanvasGroup;
break;
default:
canvasGroup = Instance.loadingCanvasGroup;
break;
}
canvasGroup.gameObject.SetActive(true);
yield return(Instance.StartCoroutine(Instance.Fade(1f, canvasGroup)));
}
private IEnumerator FadeCoroutine(AnimationCurve curve, FadeType type)
{
OnTransitionStart(type);
Transitioning = true;
AnimationCurveHelper.ChangeFirstKeyframeValue(curve, Value);
AnimationCurveHelper.ChangeLastKeyframeTime(curve, Duration);
float endTime = Duration;
float elapsedTime = 0;
while (elapsedTime <= endTime)
{
Value = curve.Evaluate(elapsedTime);
elapsedTime += Time.deltaTime;
yield return(new WaitForEndOfFrame());
}
Value = AnimationCurveHelper.LastKey(curve).value;
Transitioning = false;
OnTransitionStop(type);
}
// Update is called once per frame
void Update()
{
if (fadeType == FadeType.fadeout)
{
if (duration == 0)
{
cg.alpha = 0;
fadeType = FadeType.none;
}
else
{
cg.alpha = Mathf.Lerp(1, 0, timePassed);
timePassed += Time.deltaTime * (1 / duration);
if (cg.alpha == 0)
{
fadeType = FadeType.none;
}
}
}
if (fadeType == FadeType.fadein)
{
if (duration == 0)
{
cg.alpha = 1;
fadeType = FadeType.none;
}
else
{
cg.alpha = Mathf.Lerp(0, 1, timePassed);
timePassed += Time.deltaTime * (1 / duration);
if (cg.alpha == 1)
{
fadeType = FadeType.none;
}
}
}
}
//-----------------------------------------------------------------------------
// OnGUI
//-----------------------------------------------------------------------------
// void OnGUI(){
// //draw buttons:
// DrawFadeButton();
// DrawCameraFlashButton();
// DrawInjuryButton();
// }
//-----------------------------------------------------------------------------
// Private Methods
//-----------------------------------------------------------------------------
void DrawFadeButton()
{
//decide text to display on the button based on state of fadeDirection:
string fadeText = fadeDirection ? "down" : "up";
if (GUILayout.Button("Fade " + fadeText))
{
//set type of fadeDirection:
currentFadeType = FadeType.Fade;
//toggle state of fadeDirection:
fadeDirection = !fadeDirection;
//fade up or down based on state of fadeDirection:
if (fadeDirection)
{
ScreenFade.Fade(Color.black, ScreenFade.CurrentAlpha, 1, 1, 0, false);
}
else
{
ScreenFade.Fade(Color.black, ScreenFade.CurrentAlpha, 0, 1, 0, false);
}
}
}
public Fade(Player Player, int TargetVolume, int Length, FadeType Type)
{
if (!Player.CanFade) { return; }
if (Type == FadeType.VolumeChange && Player._Fade != null && Player._Fade.Type != FadeType.VolumeChange)
{
return;
}
this._Player = Player;
int Position = Player.Position;
this._StartPosition = Position;
this._EndPosition = Position + (int)Length;
this._StartVolume = Player.RealVolume;
this._EndVolume = TargetVolume;
this._Type = Type;
Player._Fade = this;
if (!Fade.Enabled) { this.Finish(); }
}
public FinalFade(Player Player, int Length, FadeType Type)
: base(Player, 0, Length, Type)
{
if (!Player.CanFade) { return; }
if (Player.Paused) { this.Finish(); }
Player.FadeStarted(Player, new EventArgs());
}
public void FadeOut(float time, bool resetIfOut, FadeType fadeType, float pow)
{
if (resetIfOut) {
if (FadeLevel < 0.01f) FadeLevel = 1f;
}
Fade (time, FadeLevel, 0f, fadeType, pow);
}
protected override bool ReadRealWorldParameters()
{
if (PluginName == "SSLComp") {
// <Parameters Type="RealWorld">8 1 * 3 4 3 * 1 1 1
// 0 0 0.95000000000000006661 1 0.95000000000000006661 </Parameters>
// split the parameters text into sections
string[] splittedPhrase = RealWorldParameters.Split(' ', '\n');
//Threshold (-15 - +15)
Threshold = float.Parse(splittedPhrase[0], CultureInfo.InvariantCulture); // compression threshold in dB
//Ratio (2:1=0, 4:1=1, 10:1=2)
Ratio = (RatioType) Enum.Parse(typeof(RatioType), splittedPhrase[1]);
// Fade [Off=0 or *, Out=1, In=2]
if (splittedPhrase[2] != "*") {
Fade = (FadeType) Enum.Parse(typeof(FadeType), splittedPhrase[2]);
} else {
Fade = FadeType.Off;
}
// Attack [0 - 5, .1 ms, .3 ms, 1 ms, 3 ms, 10 ms, 30 ms)
int attack = int.Parse(splittedPhrase[3]);
switch(attack) {
case 0:
Attack = 0.1f;
break;
case 1:
Attack = 0.3f;
break;
case 2:
Attack = 1.0f;
break;
case 3:
Attack = 3.0f;
break;
case 4:
Attack = 10.0f;
break;
case 5:
Attack = 30.0f;
break;
}
// Release: 0 - 4, .1 s, .3 s, .6 s, 1.2 s, Auto (-1)
int release = int.Parse(splittedPhrase[4]);
switch(release) {
case 0:
Release = 0.1f;
break;
case 1:
Release = 0.3f;
break;
case 2:
Release = 0.6f;
break;
case 3:
Release = 1.2f;
break;
case 4:
Release = -1.0f;
break;
}
//Make-Up Gain (-5 - +15) dB
MakeupGain = float.Parse(splittedPhrase[5], CultureInfo.InvariantCulture);
//*
string Delimiter1 = splittedPhrase[6];
//Rate-S (1 - +60) seconds
// Autofade duration. Variable from 1 to 60 seconds
RateS = float.Parse(splittedPhrase[7], CultureInfo.InvariantCulture);
//In
In = (splittedPhrase[8] == "1");
//Analog
Analog = (splittedPhrase[9] == "1");
return true;
} else {
return false;
}
}
public void PlayFadeOut()
{
fadeType = FadeType.FADEOUT;
Reset();
isActive = true;
}
/**
* <summary>Fades the camera out.</summary>
* <param name = "_timeToFade">The duration, in seconds, of the fade effect</param>
*/
public void FadeOut(float _timeToFade)
{
AssignFadeTexture ();
if (alpha == 0f)
{
alpha = 0.01f;
}
if (_timeToFade > 0f)
{
alpha = Mathf.Clamp01 (alpha);
timeToFade = _timeToFade;
fadeType = FadeType.fadeOut;
fadeStartTime = Time.time - (alpha * timeToFade);
}
else
{
alpha = 1f;
timeToFade = 0f;
}
}
/**
* <summary>Fades the camera in.</summary>
* <param name = "_timeToFade">The duration, in seconds, of the fade effect</param>
* <param name = "forceCompleteTransition">If True, the camera will be faded out instantly before beginning</param>
*/
public void FadeIn(float _timeToFade, bool forceCompleteTransition = true)
{
AssignFadeTexture ();
if ((forceCompleteTransition || alpha > 0f) && _timeToFade > 0f)
{
if (forceCompleteTransition)
{
alpha = 1f;
fadeStartTime = Time.time;
}
else
{
fadeStartTime = Time.time - (_timeToFade * (1f - alpha));
}
timeToFade = _timeToFade;
fadeType = FadeType.fadeIn;
}
else
{
alpha = 0f;
timeToFade = 0f;
ReleaseFadeTexture ();
}
}
/// <summary>
/// Fade from one value to another.
/// </summary>
public void Fade(float time, float start, float end, FadeType fadeType, float pow)
{
int position = AddFading ();
CancelAllOtherFading (position);
Fader.Instance.Fade (this, time, start, end, position, fadeType, pow);
}
private IEnumerator CoFade(Fadeable f, float time, float start, float end, int fadingPosition, FadeType fadeType, float pow)
{
if (time == 0) yield break;
float eTime = 0f;
f.fading[fadingPosition] = true;
f.FadeLevel = start;
while (eTime < time && f.fading[fadingPosition]) {
eTime += Time.deltaTime;
switch (fadeType) {
case FadeType.Lin:
f.FadeLevel = Mathf.Lerp (start, end, eTime / time);
break;
case FadeType.Exp:
f.FadeLevel = MathfExtended.SteepErp (start, end, pow, eTime / time);
break;
case FadeType.Log:
f.FadeLevel = MathfExtended.ShallowErp (start, end, pow, eTime / time);
break;
}
yield return 0;
}
if (f.fading[fadingPosition]) {
f.FadeLevel = end;
f.fading[fadingPosition] = false;
}
}
public void Fade(Fadeable f, float time, float start, float end, int fadingPosition, FadeType fadeType, float pow)
{
StartCoroutine (CoFade (f, time, start, end, fadingPosition, fadeType, pow));
}
public void FadeTo(float time, float end, FadeType fadeType, float pow)
{
Fade (time, FadeLevel, end, fadeType, pow);
}
void DrawInjuryButton(){
if ( GUILayout.Button( "Injury" ) ) {
fadeDirection = false;
currentFadeType = FadeType.Injury;
ScreenFade.Fade( Color.red, .6f, 0, .35f, 0, true );
cachedAudioSource.pitch = Random.Range ( .99f, 1.1f );
PlaySound( injurySound, .1f );
}
}
/**
* <summary>Fades the camera in.</summary>
* <param name = "_timeToFade">The duration, in seconds, of the fade effect</param>
*/
public void FadeIn(float _timeToFade)
{
AssignFadeTexture ();
if (_timeToFade > 0f)
{
timeToFade = _timeToFade;
alpha = 1f;
fadeType = FadeType.fadeIn;
fadeStartTime = Time.time;
}
else
{
alpha = 0f;
timeToFade = 0f;
ReleaseFadeTexture ();
}
}
/**
* <summary>Fades the camera out.</summary>
* <param name = "_timeToFade">The duration, in seconds, of the fade effect</param>
* <param name = "forceCompleteTransition">If True, the camera will be faded in instantly before beginning</param>
*/
public void FadeOut(float _timeToFade, bool forceCompleteTransition = true)
{
AssignFadeTexture ();
if (alpha == 0f)
{
alpha = 0.01f;
}
if ((forceCompleteTransition || alpha < 1f) && _timeToFade > 0f)
{
if (forceCompleteTransition)
{
alpha = 0.01f;
fadeStartTime = Time.time;
}
else
{
alpha = Mathf.Clamp01 (alpha);
fadeStartTime = Time.time - (alpha * timeToFade);
}
timeToFade = _timeToFade;
fadeType = FadeType.fadeOut;
}
else
{
alpha = 1f;
timeToFade = 0f;
}
}
public void PlayFadeIn()
{
fadeType = FadeType.FADEIN;
Reset();
isActive = true;
}
public StopSettings(Metronome metronome, SnapStyle snapStyle, float beat, float delay, float fadeLength, FadeType fadeType, float power)
: this(true, metronome, snapStyle, beat, delay, fadeLength, fadeType, power)
{
}
public void FadeIn(float time, bool resetIfIn, FadeType fadeType, float pow)
{
if (resetIfIn) {
if (FadeLevel > 0.99f) FadeLevel = 0f;
}
Fade (time, FadeLevel, 1f, fadeType, pow);
}
public float updateTime = 0.25f; // We call Decay() every updateTime seconds
#endregion Fields
#region Constructors
public Settings(bool autoDecay, float decayTime, FadeType decayCurve, float power)
{
this.autoDecay = autoDecay;
this.decayTime = decayTime;
this.decayCurve = decayCurve;
this.power = power;
}
protected void SetFinalFade(Player Player, int Length, FadeType Type)
{
new FinalFade(Player, Length, Type);
}
public void FadeOut(float time, FadeType fadeType, float pow)
{
FadeOut (time, true, fadeType, pow);
}
