public static float EaseElastic(float x) { return(x.Approximately(0f) ? 0f : x.Approximately(1f) ? 1f : Mathf.Pow(2f, -10f * x) * Mathf.Sin((x * 10f - 0.75f) * ElasticConst) + 1); }
// Expo: public static float EaseInOutExpo(float x) { return(x.Approximately(0f) ? 0f : x.Approximately(1f) ? 1f : x < 0.5f ? Mathf.Pow(2f, 20f * x - 10f) / 2f : (2f - Mathf.Pow(2f, -20f * x + 10f)) / 2f); }
void SetRatio(float ratio) { if (GaugeType == AnimType.Invalid) { SetType(); } if ((GaugeType & AnimType.Translate) != 0) { transform.localPosition = Vector3.LerpUnclamped(PositionMin, PositionMax, ratio); } if ((GaugeType & AnimType.Scale) != 0) { transform.localScale = Vector3.LerpUnclamped(ScaleMin, ScaleMax, ratio); } if ((GaugeType & AnimType.Rotate) != 0) { transform.localEulerAngles = Vector3.LerpUnclamped(RotationMin, RotationMax, ratio); } if ((GaugeType & AnimType.Color) != 0) { foreach (var renderer in Renderers) { renderer.material.color = Color.LerpUnclamped(ColorMin, ColorMax, ratio); } } if ((GaugeType & AnimType.Enable) != 0) { gameObject.SetActive(EnableAt == 1f ? ratio.Approximately(1f, 0.003f) : ratio >= EnableAt); } if ((GaugeType & AnimType.Particles) != 0) { if (ParticlesAt == 1f ? ratio.Approximately(1f, 0.003f) : ratio >= ParticlesAt) { foreach (var particle in Particles) { particle.Play(); } } else { foreach (var particle in Particles) { particle.Stop(); } } } }
private void Update() { if (!m_LastValue.Approximately(m_Control.value)) { m_LastValue = m_Variable.Progress = m_Control.value; } }
protected override IEnumerator OnComplete() { yield return(base.OnComplete()); if (!_duration.Approximately(0)) { yield return(YieldInstructioner.GetWaitForSeconds(_duration)); } }
public void Out(float duration, AnimationCurve curve, Action callback) { m_Callback = callback ?? (() => { }); if (duration.Approximately(0)) { Hide(); } else { To(0, duration, curve); } }
public IProgress UpdateProgress(long value, long total, string message = null, IProgress innerProgress = null, bool dontInvoke = false) { InnerProgress = innerProgress; Total = total == 0 ? 100 : total; Value = value > Total ? Total : value; string previousMessage = Message; Message = string.IsNullOrEmpty(message) ? Message : message; float fTotal = Total; float fValue = Value; Percentage = fValue / fTotal; float delta = (fValue / fTotal - previousValue / fTotal) * 100f; bool shouldSignal = Changed || (innerProgress?.Changed ?? false) || previousMessage != Message || fValue.Approximately(0f) || delta > 1f || fValue.Approximately(fTotal) || (innerProgress?.Percentage.Approximately(1f) ?? false); ; if (shouldSignal) { // signal progress in 1% increments or if we don't know what the total is previousValue = Value; var ret = new ProgressData(Task, Percentage, Value, Total, Message, innerProgress); if (!dontInvoke) { OnProgress?.Invoke(ret); } return(ret); } return(this); }
private void UpdateFade() { if (!m_InTransition) { return; } if (!FadeComplete) { Alpha = Mathf.Lerp(m_FadeStart, m_FadeTarget, m_FadeCurve.Evaluate(m_FadeTarget.Approximately(0) ? 1 - FadeProgress : FadeProgress)); } else { CompleteFade(); } }
protected virtual void Update() { if (isDragging) { currentRotation = -velocityMultiplier * (storedPointer.Position.y - prevPointerYPos); rotatingObject.Rotate(0f, currentRotation, 0f); prevPointerYPos = storedPointer.Position.y; } else { if (!currentRotation.Approximately(0f, 0.1f)) { currentRotation -= Mathf.Sign(currentRotation) * velocityDampen * Time.deltaTime; rotatingObject.Rotate(0f, currentRotation, 0f); } } }
private static IEnumerator To(float duration, ProgressChanged onProgress) { if (duration.Approximately(0f)) { onProgress(1f); yield break; } float time = 0f; while (time < duration) { onProgress(time / duration); time += Time.deltaTime; yield return(null); } onProgress(1f); }
protected void UpdateDisplayString(float buttonWidth) { if (m_LastButtonWidth.Approximately(buttonWidth)) { return; } m_LastButtonWidth = buttonWidth; m_DisplayString = FullName; string trimmedString = m_DisplayString; float currentWidth = GUI.skin.label.CalcSize(new GUIContent(m_DisplayString)).x; int startIndex = 0; while (currentWidth > buttonWidth - kDisplayTextBuffer && startIndex < m_DisplayString.Length) { ++startIndex; trimmedString = "..." + m_DisplayString.Substring(startIndex, m_DisplayString.Length - startIndex); currentWidth = GUI.skin.label.CalcSize(new GUIContent(trimmedString)).x; } m_DisplayString = trimmedString; }
private static IEnumerator To(float duration, Action <float> onProgressChanged) { if (duration.Approximately(0f)) { onProgressChanged(1f); yield break; } float _time = 0f; while (_time < duration) { onProgressChanged(_time / duration); _time += Time.deltaTime; yield return(null); } onProgressChanged(1f); }
private float GetXVelocity(float startT, float t, out bool finished) { finished = false; if (prevXVelocityCurve == null) { return(prevVelocity.x); } if (prevIsDeaccel) { float v = prevXVelocityCurve.Evaluate(startT + t) * Mathf.Sign(prevVelocity.x); finished = v.Approximately(0, 0.1f); return(v); } else { float v = prevXVelocityCurve.Evaluate(startT + t) * Mathf.Sign(input.Movement.x); finished = Mathf.Abs(v) >= prevXVelocityCurve.Evaluate(1000) - 0.2f; return(v); } }
private void Update() { if (!m_Cam) { return; } float currentAspect = (float)Screen.width / Screen.height; if (currentAspect.Approximately(m_LastAspect, 0.01f)) { return; } m_LastAspect = currentAspect; if (m_LastAspect.Approximately(WantedAspectRatio, 0.01f)) { m_Cam.rect = new Rect(0.0f, 0.0f, 1.0f, 1.0f); return; } // Pillarbox if (m_LastAspect > WantedAspectRatio) { float inset = 1.0f - WantedAspectRatio / m_LastAspect; m_Cam.rect = new Rect(inset / 2, 0.0f, 1.0f - inset, 1.0f); } // Letterbox else { float inset = 1.0f - m_LastAspect / WantedAspectRatio; m_Cam.rect = new Rect(0.0f, inset / 2, 1.0f, 1.0f - inset); } }
// Token: 0x0600036B RID: 875 RVA: 0x0000C37A File Offset: 0x0000A57A public static bool Approximately(this float first, float second) { return(first.Approximately(second, float.Epsilon)); }
public bool ConditionMatched(ModuleBlockMover block, bool localInput, float m_Val, float m_Vel) { bool Invert = m_InputParam < 0; switch (m_InputType) { case InputType.AlwaysOn: return(true); case InputType.OnPress: m_InputParam = Mathf.Sign(m_InputParam); return((KeyState(CanInput(block, localInput)) == 1) != Invert); case InputType.OnRelease: m_InputParam = Mathf.Sign(m_InputParam); return((KeyState(CanInput(block, localInput)) == 3) != Invert); case InputType.WhileHeld: m_InputParam = Mathf.Sign(m_InputParam); return((KeyState(CanInput(block, localInput)) != 0) != Invert); case InputType.Toggle: m_InputParam = Mathf.Sign(m_InputParam - 0.001f); if (KeyState(CanInput(block, localInput)) == 1) { m_InputParam = -m_InputParam; } return(m_InputParam > 0); case InputType.EnemyTechIsNear: Visible target = block.GetTarget(); if (target == null) { return(Invert); } return(((target.centrePosition - block.block.centreOfMassWorld).sqrMagnitude < m_InputParam * m_InputParam) != Invert); case InputType.PlayerTechIsNear: if (Singleton.playerTank == null) { return(Invert); } if (Singleton.playerTank == block.block.tank) { return(!Invert); } return(((Singleton.playerTank.visible.centrePosition - block.block.centreOfMassWorld).sqrMagnitude < m_InputParam * m_InputParam) != Invert); case InputType.AboveSurfaceElev: var comw = block.block.centreOfMassWorld; ManWorld.inst.GetTerrainHeight(comw, out float outHeight); return((comw.y > outHeight + m_InputParam) != Invert); case InputType.AboveVelocity: return((block.block.tank.rbody.GetPointVelocity(block.block.centreOfMassWorld).sqrMagnitude > m_InputParam * m_InputParam) != Invert); case InputType.IfPosAbove: if (block.IsPlanarVALUE) { return(((block.PVALUE + 900) % 360) - 180 > m_InputParam); } m_InputParam = Mathf.Max(m_InputParam, 0f); return(block.PVALUE > m_InputParam); case InputType.IfPosBelow: if (block.IsPlanarVALUE) { return(((block.PVALUE + 900) % 360) - 180 < m_InputParam); } m_InputParam = Mathf.Max(m_InputParam, 0f); return(block.PVALUE < m_InputParam); case InputType.IfPosEqual: if (block.IsPlanarVALUE) { return(m_InputParam.Approximately(((block.PVALUE + 900) % 360) - 180)); } m_InputParam = Mathf.Max(m_InputParam, 0f); return(block.PVALUE.Approximately(m_InputParam)); case InputType.IfSpeedAbove: return(m_Vel > m_InputParam); case InputType.IfSpeedBelow: return(m_Vel < m_InputParam); case InputType.IfSpeedEqual: return(m_Vel.Approximately(m_InputParam)); default: return(false); } }
public static float RoundToMultipleOf(float value, float multiple) => multiple.Approximately(0) ? value : (value / multiple).Round() * multiple;
public static float EaseOutExpo(float x) { return(x.Approximately(1f) ? 1f : 1 - Mathf.Pow(2f, -10f * x)); }
public static float EaseInExpo(float x) { return(x.Approximately(0f) ? 0f : Mathf.Pow(2f, 10f * x - 10f)); }
// Currently this expects a string of plain text, // and will not correctly handle rich text tags etc. private IEnumerator FadeTextByWord(string text) { MatchCollection words = Regex.Matches(text, @"\S+\s*"); int length = words.Count; float duration = text.Length / m_TravelSpeed; float wordPerSecond = duration / words.Count; // Build a character buffer of our desired text, // with a rich text "color" tag around every word. StringBuilder builder = new StringBuilder(); Color32 color = m_Text.color; string startColor = string.Format("<color=#{0}{1}{2}{3}{4}{5}00>", s_NibbleToHex[color.r >> 4], s_NibbleToHex[color.r & 0xF], s_NibbleToHex[color.g >> 4], s_NibbleToHex[color.g & 0xF], s_NibbleToHex[color.b >> 4], s_NibbleToHex[color.b & 0xF]); Dictionary <int, int> alphaIndexes = new Dictionary <int, int>(); Debug.Log("String length = " + text.Length + " and word count = " + length); for (int i = 0; i < length; i++) { Match current = words[i]; builder.Append(startColor); alphaIndexes[i] = builder.Length - 3; builder.Append(current.Value); builder.Append("</color>"); } // Each frame, update the alpha values along the fading frontier. float fadingProgress = 0f; int opaqueWords = -1; while (opaqueWords < length - 1) { yield return(null); fadingProgress += Time.deltaTime; float leadingEdge = fadingProgress / wordPerSecond; int lastWord = Mathf.Min(length - 1, Mathf.FloorToInt(leadingEdge)); int newOpaque = opaqueWords; for (int i = lastWord; i > opaqueWords; i--) { byte fade = (byte)(m_FadeDuration.Approximately(0) ? 255f : (255f * Mathf.Clamp01((leadingEdge - i) / (wordPerSecond * m_FadeDuration)))); builder[alphaIndexes[i]] = s_NibbleToHex[fade >> 4]; builder[alphaIndexes[i] + 1] = s_NibbleToHex[fade & 0xF]; if (fade == 255) { newOpaque = Mathf.Max(newOpaque, i); } } opaqueWords = newOpaque; // This allocates a new string. m_Text.text = builder.ToString(); } // Once all the characters are opaque, // ditch the unnecessary markup and end the routine. m_Text.text = text; // Mark the fade transition as finished. // This can also fire an event/message if you want to signal UI. m_Fade = null; OnComplete.Invoke(); }
public static bool Approximately(this float f, float f2) { return(f.Approximately(f2, Mathf.Epsilon)); }
private static float ElasticOut(float t) => t.Approximately(1f) ? 1f : 1f - ElasticIn(1f - t);