private IEnumerator DelayedStart() { audioSource.volume = 0; yield return(new WaitForSeconds(4)); volumeTween.Tween(audioSource.volume, normalVolume, 12, AnimationCurve.EaseInOut(0, 0, 1, 1)); }
internal TimelineClip CreateNewClipContainerInternal() { var clipContainer = new TimelineClip(this); clipContainer.asset = null; // position clip at end of sequence var newClipStart = 0.0; for (var a = 0; a < m_Clips.Count - 1; a++) { var clipDuration = m_Clips[a].duration; if (double.IsInfinity(clipDuration)) { clipDuration = TimelineClip.kDefaultClipDurationInSeconds; } newClipStart = Math.Max(newClipStart, m_Clips[a].start + clipDuration); } clipContainer.mixInCurve = AnimationCurve.EaseInOut(0, 0, 1, 1); clipContainer.mixOutCurve = AnimationCurve.EaseInOut(0, 1, 1, 0); clipContainer.start = newClipStart; clipContainer.duration = TimelineClip.kDefaultClipDurationInSeconds; clipContainer.displayName = "untitled"; return(clipContainer); }
/// <summary> /// Constructor /// </summary> public P2DAbstractForceController(Transform xf, List <Rigidbody2D> bodies, AABB container) : base(ControllerType.WindController, xf, bodies, container) { Strength = 1.0f; Position = new Vector2(0, 0); MaximumSpeed = 100.0f; TimingMode = WindType.Constant; ImpulseTime = 0.0f; Variation = 0.0f; Randomize = new System.Random(); DecayMode = DecayMode.None; DecayStart = 0.0f; DecayEnd = 0.0f; StrengthCurve = new AnimationCurve(); StrengthCurve.AddKey(new Keyframe(0, 0)); StrengthCurve.AddKey(new Keyframe(0.1f, -4)); StrengthCurve.AddKey(new Keyframe(0.2f, 5)); StrengthCurve.AddKey(new Keyframe(0.4f, 5)); StrengthCurve.AddKey(new Keyframe(0.5f, 0)); StrengthCurve.AddKey(new Keyframe(0.65f, -3)); StrengthCurve.AddKey(new Keyframe(0.8f, 0)); StrengthCurve.postWrapMode = WrapMode.Loop; DecayCurve = new AnimationCurve(); DecayCurve = AnimationCurve.EaseInOut(0, 1, 10, 0); }
// Token: 0x06000674 RID: 1652 RVA: 0x0001E610 File Offset: 0x0001C810 public override void OnExit() { this.CreateBlinkEffect(base.transform.position); this.modelTransform = base.GetModelTransform(); if (this.modelTransform) { TemporaryOverlay temporaryOverlay = this.modelTransform.gameObject.AddComponent <TemporaryOverlay>(); temporaryOverlay.duration = 0.6f; temporaryOverlay.animateShaderAlpha = true; temporaryOverlay.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f); temporaryOverlay.destroyComponentOnEnd = true; temporaryOverlay.originalMaterial = Resources.Load <Material>("Materials/matHuntressFlashBright"); temporaryOverlay.AddToCharacerModel(this.modelTransform.GetComponent <CharacterModel>()); TemporaryOverlay temporaryOverlay2 = this.modelTransform.gameObject.AddComponent <TemporaryOverlay>(); temporaryOverlay2.duration = 0.7f; temporaryOverlay2.animateShaderAlpha = true; temporaryOverlay2.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f); temporaryOverlay2.destroyComponentOnEnd = true; temporaryOverlay2.originalMaterial = Resources.Load <Material>("Materials/matHuntressFlashExpanded"); temporaryOverlay2.AddToCharacerModel(this.modelTransform.GetComponent <CharacterModel>()); } if (this.characterModel) { this.characterModel.invisibilityCount--; } if (this.hurtboxGroup) { HurtBoxGroup hurtBoxGroup = this.hurtboxGroup; int hurtBoxesDeactivatorCounter = hurtBoxGroup.hurtBoxesDeactivatorCounter - 1; hurtBoxGroup.hurtBoxesDeactivatorCounter = hurtBoxesDeactivatorCounter; } base.OnExit(); }
private void AddEliteMaterials(On.RoR2.CharacterBody.orig_FixedUpdate orig, RoR2.CharacterBody self) { if (self.HasBuff(EliteBuffIndex) && !self.GetComponent <RadiantBuffTracker>()) { var modelLocator = self.modelLocator; if (modelLocator) { var modelTransform = self.modelLocator.modelTransform; if (modelTransform) { var model = self.modelLocator.modelTransform.GetComponent <RoR2.CharacterModel>(); if (model) { var radiantBuffTracker = self.gameObject.AddComponent <RadiantBuffTracker>(); radiantBuffTracker.Body = self; RoR2.TemporaryOverlay overlay = self.modelLocator.modelTransform.gameObject.AddComponent <RoR2.TemporaryOverlay>(); overlay.duration = float.PositiveInfinity; overlay.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f); overlay.animateShaderAlpha = true; overlay.destroyComponentOnEnd = true; overlay.originalMaterial = EliteMaterial; overlay.AddToCharacerModel(model); radiantBuffTracker.Overlay = overlay; radiantBuffTracker.PulseTimer = 1; } } } } orig(self); }
public void UpdateFromConverter(CameraStatusConverter converter) { hasTarget = converter.willHaveTarget; hasOrientation = converter.willHaveOrientation; currentTarget = converter.nextTarget; currentOrientation = converter.nextOrientation; focusDelta = converter.intendedFocusDelta; toTargetMaxDelta = converter.toTargetMaxSpeed * Time.deltaTime; cameraMaxDelta = converter.cameraMaxSpeed * Time.deltaTime; switch (converter.sizeStyle) { case CurveStyle.Instantly: size = converter.intendedSize; sizeCurve = AnimationCurve.Constant(0f, 1f, size); break; case CurveStyle.Linear: ResetTimer(); sizeCurve = AnimationCurve.Linear(0f, size, converter.time, converter.intendedSize); break; case CurveStyle.EaseInOut: ResetTimer(); sizeCurve = AnimationCurve.EaseInOut(0f, size, converter.time, converter.intendedSize); break; } }
IEnumerator CooldownAnimation(bool isStartCooldown) { if (originalPos == Vector3.zero) { originalPos = transform.position; } float timePassed = 0; AnimationCurve curve = AnimationCurve.EaseInOut(0, 0, 1, 1); Vector3 startPos = transform.position; Vector3 targetPos = new Vector3( originalPos.x, isStartCooldown? (originalPos.y - cooldownYOffset): originalPos.y, originalPos.z ); while (timePassed < cooldownAnimationDuration) { yield return(new WaitForFixedUpdate()); timePassed += Time.deltaTime; transform.position = Vector3.Lerp(startPos, targetPos, curve.Evaluate(timePassed / cooldownAnimationDuration)); } transform.position = targetPos; cooldownAnimation = null; }
public void FadeOut() { m_AlphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f); m_loop = false; m_maxAlpha = m_projector.material.color.a; m_beginTime = Time.time; }
/// <summary> /// set the animation curve using a preset /// </summary> public void SetCurve(BasicEaseCurves curve) { AnimationCurve animation = AnimationCurve.Linear(0, 1, 1, 1); switch (curve) { case BasicEaseCurves.EaseIn: animation = new AnimationCurve(new Keyframe(0, 0), new Keyframe(1, 1, 2.5f, 0)); break; case BasicEaseCurves.EaseOut: animation = new AnimationCurve(new Keyframe(0, 0, 0, 2.5f), new Keyframe(1, 1)); break; case BasicEaseCurves.EaseInOut: animation = AnimationCurve.EaseInOut(0, 0, 1, 1); break; default: break; } Curve = animation; // Update the cached keys cachedKeys = Curve.keys; }
public IEnumerator SetColorPingPong(SpriteRenderer spr, Color StartColor, Color EndColor, float time, int count) { float t = 0f; AnimationCurve curve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f); spr.SetColor(StartColor); Color oneColor = StartColor; for (int i = 0; i < count * 2; ++i) { while (t < 1.0f) { t = Mathf.Clamp01(t + Time.unscaledDeltaTime / time); float r = Mathf.Lerp(StartColor.r, EndColor.r, curve.Evaluate(t)); float g = Mathf.Lerp(StartColor.g, EndColor.g, curve.Evaluate(t)); float b = Mathf.Lerp(StartColor.b, EndColor.b, curve.Evaluate(t)); float a = Mathf.Lerp(StartColor.a, EndColor.a, curve.Evaluate(t)); spr.SetColor(new Color(r, g, b, a)); yield return(null); } t = 0f; Color temp = StartColor; StartColor = EndColor; EndColor = temp; } spr.SetColor(oneColor); }
public override void OnInspectorGUI() { base.OnInspectorGUI(); var warp = (TeleportTransitionWarp)target; warp.PositionLerp = EditorGUILayout.CurveField("Position Lerp", warp.PositionLerp, GUILayout.Height(50)); GUILayout.BeginHorizontal(); GUILayout.Label("Position Lerp Modes"); if (GUILayout.Button("Default")) { warp.PositionLerp = AnimationCurve.Linear(0, 0, 1, 1); } if (GUILayout.Button("Ease")) { warp.PositionLerp = AnimationCurve.EaseInOut(0, 0, 1, 1); } if (GUILayout.Button("Step 5")) { CreateStep(warp, 5); } if (GUILayout.Button("Step 10")) { CreateStep(warp, 10); } GUILayout.EndHorizontal(); }
public static int EaseInOut_s(IntPtr l) { int result; try { float timeStart; LuaObject.checkType(l, 1, out timeStart); float valueStart; LuaObject.checkType(l, 2, out valueStart); float timeEnd; LuaObject.checkType(l, 3, out timeEnd); float valueEnd; LuaObject.checkType(l, 4, out valueEnd); AnimationCurve o = AnimationCurve.EaseInOut(timeStart, valueStart, timeEnd, valueEnd); LuaObject.pushValue(l, true); LuaObject.pushValue(l, o); result = 2; } catch (Exception e) { result = LuaObject.error(l, e); } return(result); }
public static IEnumerator Rotate(GameObject door, float StartAngle, float EndAngle, float Speed, bool UnityConvention, float Offset, bool ShortestWay) { Quaternion StartRotation, EndRotation, RotationOffset; RotationOffset = Quaternion.Euler(0, Offset, 0); AnimationCurve curve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f); float TimeProgression = 0f; if (UnityConvention) // Unity Convention { StartRotation = Quaternion.Euler(0, StartAngle, 0); EndRotation = Quaternion.Euler(0, EndAngle, 0); } else // Alex's Door System Convention { StartRotation = Quaternion.Euler(0, -StartAngle, 0); EndRotation = Quaternion.Euler(0, -EndAngle, 0); } while (TimeProgression <= (1 / Speed)) { TimeProgression += Time.deltaTime; float RotationProgression = Mathf.Clamp01(TimeProgression / (1 / Speed)); float RotationCurveValue = curve.Evaluate(RotationProgression); door.transform.rotation = Lerp(StartRotation * RotationOffset, EndRotation * RotationOffset, RotationCurveValue, ShortestWay); yield return(null); } }
public static void RubyMatUpdate(CharacterBody self) { if (self && self.inventory) { EliteIndex equipmentEliteIndex = RoR2.EliteCatalog.GetEquipmentEliteIndex(self.inventory.GetEquipmentIndex()); if (self && equipmentEliteIndex == EliteIndex.None && self.isElite) { int itemCount = self.inventory.GetItemCount(Assets.AffixOrangeItemIndex); if (itemCount > 0) { equipmentEliteIndex = EliteAspectsChanges.AffixOrangeIndex; } } RoR2.CharacterModel characterModelFromCharacterBody = CloudUtils.GetCharacterModelFromCharacterBody(self); if (equipmentEliteIndex == EliteAspectsChanges.AffixOrangeIndex && !self.gameObject.GetComponent <DestroyEffectOnBuffEnd>() && characterModelFromCharacterBody) { DestroyEffectOnBuffEnd destroyEffectOnBuffEnd = self.gameObject.AddComponent <DestroyEffectOnBuffEnd>(); destroyEffectOnBuffEnd.body = self; destroyEffectOnBuffEnd.buff = EliteAspectsChanges.AffixOrangeBuff; RoR2.TemporaryOverlay temporaryOverlay = characterModelFromCharacterBody.gameObject.AddComponent <RoR2.TemporaryOverlay>(); temporaryOverlay.duration = float.PositiveInfinity; temporaryOverlay.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f); temporaryOverlay.animateShaderAlpha = true; temporaryOverlay.destroyComponentOnEnd = true; temporaryOverlay.originalMaterial = Cloudburst.Cores.AssetsCore.mainAssetBundle.LoadAsset <Material>("Assets/Cloudburst/753network/Crystallize/Ruby.mat"); temporaryOverlay.AddToCharacerModel(characterModelFromCharacterBody); destroyEffectOnBuffEnd.effect = temporaryOverlay; } } }
private IEnumerator IESetActive(bool _value) { Vector3 _startValue = transform.localScale; AnimationCurve _curve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f); if (lookAtCamera && _value) { lookAtCameraScript.SetActive(true); } float _timeKey = 0; while (_timeKey < 1) { _timeKey += Time.deltaTime / lerpScaleDuration; float _evaluatedTimeKey = _curve.Evaluate(_timeKey); transform.localScale = Vector3.Lerp(_startValue, _value ? openedScale : closedScale, _evaluatedTimeKey); yield return(null); } if (lookAtCamera && !_value) { lookAtCameraScript.SetActive(false); } yield return(null); }
public void captain(Animation a) { AnimationClip ac = new AnimationClip(); ac.legacy = true; //se voltea AnimationCurve rot = AnimationCurve.EaseInOut(18f, gameObject.transform.eulerAngles.y, 20f, gameObject.transform.eulerAngles.y - 180); //Evento de animación de caminar 1 AnimationEvent cWalk = new AnimationEvent(); cWalk.time = 21; cWalk.functionName = "walkCycle"; ac.AddEvent(cWalk); //camina AnimationCurve xgap = AnimationCurve.EaseInOut(21f, gameObject.transform.position.x, 27f, 2.6f); AnimationCurve zgap = AnimationCurve.EaseInOut(21f, gameObject.transform.position.z, 27f, 0.5f); AnimationCurve despawn = AnimationCurve.EaseInOut(25.35f, gameObject.transform.position.y, 29f, -2f); ac.SetCurve("", typeof(Transform), "localPosition.x", xgap); ac.SetCurve("", typeof(Transform), "localPosition.y", despawn); ac.SetCurve("", typeof(Transform), "localPosition.z", zgap); ac.SetCurve("", typeof(Transform), "localEulerAngles.y", rot); a.AddClip(ac, "capi"); a.Play("capi"); }
void AdjustPlayerPositions() { int Radius = 5; if (players.Length > 5) { Radius = players.Length; Camera.main.orthographicSize = players.Length + 2; } //NOTE: When using Cos and Sin to get the values for X and Y, the circle starts from (1,0) i.e. leftmost position on the unit circle int numPositions = players.Length; float degreeInterval = 360 / numPositions; Debug.Log(string.Format("{0} players, {1} degrees between each, {2} radius", numPositions, degreeInterval, Radius)); for (int i = 0; i < players.Length; i++) { float currentDegree = i * degreeInterval; float currentCos = Mathf.Cos(currentDegree * Mathf.Deg2Rad); float currentSin = Mathf.Sin(currentDegree * Mathf.Deg2Rad); //Debug.Log(string.Format("New Position for player {0}: {1:f2},{2:f2}", i + 1, currentCos, currentSin)); players[i].xCurve = AnimationCurve.EaseInOut(0, 0, 1, currentCos * Radius); players[i].yCurve = AnimationCurve.EaseInOut(0, 0, 1, currentSin * Radius); //---Old non-animated way of positioning cards after the deal---// //players[i].gameObject.transform.Translate(currentCos * Radius, currentSin * Radius, 0); } curvesCalculated = true; Debug.Log("Curves Calculated"); }
public void order(Animation a, float x, float z, float alpha) { AnimationClip ac = new AnimationClip(); ac.legacy = true; //Gira AnimationCurve rot = AnimationCurve.EaseInOut(alpha + 30f, gameObject.transform.eulerAngles.y, alpha + 30.5f, goTo(x, z)); //Eventos de animación de caminar AnimationEvent cWalk = new AnimationEvent(); cWalk.time = alpha + 30.5f; cWalk.functionName = "walkCycle"; ac.AddEvent(cWalk); cWalk = new AnimationEvent(); cWalk.time = alpha + 36f; cWalk.functionName = "walkCycle"; ac.AddEvent(cWalk); //camina AnimationCurve xgap = AnimationCurve.EaseInOut(alpha + 30.5f, gameObject.transform.position.x, alpha + 36f, x); AnimationCurve zgap = AnimationCurve.EaseInOut(alpha + 30.5f, gameObject.transform.position.z, alpha + 36f, z); ac.SetCurve("", typeof(Transform), "localPosition.x", xgap); ac.SetCurve("", typeof(Transform), "localPosition.y", AnimationCurve.Constant(30, 50, gameObject.transform.localPosition.y)); ac.SetCurve("", typeof(Transform), "localPosition.z", zgap); ac.SetCurve("", typeof(Transform), "localEulerAngles.y", rot); a.AddClip(ac, "order"); a.Play("order"); }
public void UpdateFromConverter(PlayerStatusConverter converter) { switch (converter.style) { case CurveStyle.Instantly: speed = converter.intendedSpeed; rotationSpeed = converter.intendedRotationalSpeed; speedCurve = AnimationCurve.Constant(0f, 1f, speed); rotationalSpeedCurve = AnimationCurve.Constant(0f, 1f, rotationSpeed); break; case CurveStyle.Linear: ResetTimer(); speedCurve = AnimationCurve.Linear(0f, speed, converter.time, converter.intendedSpeed); rotationalSpeedCurve = AnimationCurve.Linear(0f, rotationSpeed, converter.time, converter.intendedRotationalSpeed); break; case CurveStyle.EaseInOut: ResetTimer(); speedCurve = AnimationCurve.EaseInOut(0f, speed, converter.time, converter.intendedSpeed); rotationalSpeedCurve = AnimationCurve.EaseInOut(0f, rotationSpeed, converter.time, converter.intendedRotationalSpeed); break; } }
// Token: 0x06002F2B RID: 12075 RVA: 0x000C9698 File Offset: 0x000C7898 public override void OnExit() { Util.PlaySound(BlinkState.endSoundString, base.gameObject); this.CreateBlinkEffect(Util.GetCorePosition(base.gameObject)); this.modelTransform = base.GetModelTransform(); if (this.modelTransform && BlinkState.destealthMaterial) { TemporaryOverlay temporaryOverlay = this.animator.gameObject.AddComponent <TemporaryOverlay>(); temporaryOverlay.duration = 1f; temporaryOverlay.destroyComponentOnEnd = true; temporaryOverlay.originalMaterial = BlinkState.destealthMaterial; temporaryOverlay.inspectorCharacterModel = this.animator.gameObject.GetComponent <CharacterModel>(); temporaryOverlay.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f); temporaryOverlay.animateShaderAlpha = true; } if (this.characterModel) { this.characterModel.invisibilityCount--; } if (this.hurtboxGroup) { HurtBoxGroup hurtBoxGroup = this.hurtboxGroup; int hurtBoxesDeactivatorCounter = hurtBoxGroup.hurtBoxesDeactivatorCounter - 1; hurtBoxGroup.hurtBoxesDeactivatorCounter = hurtBoxesDeactivatorCounter; } if (base.characterMotor) { base.characterMotor.enabled = true; } base.PlayAnimation("Gesture, Additive", "BlinkEnd"); base.OnExit(); }
/// <summary> /// Constructor. Semi-internal - If you use this be prepared for changes. The best way is to use named /// parameters for all optional arguments! /// </summary> /// <param name="target"></param> /// <param name="delay"></param> /// <param name="duration"></param> /// <param name="transitionMode"></param> /// <param name="timeUpdateMethod"></param> /// <param name="tweenType"></param> /// <param name="animationCurve"></param> /// <param name="coordinateSpace"></param> /// <param name="onStart"></param> /// <param name="onUpdate"></param> /// <param name="onComplete"></param> public TransitionStep(UnityEngine.GameObject target = null, float delay = 0, float duration = 0.5f, TransitionModeType transitionMode = TransitionModeType.Specified, TimeUpdateMethodType timeUpdateMethod = TimeUpdateMethodType.GameTime, TransitionHelper.TweenType tweenType = TransitionHelper.TweenType.linear, AnimationCurve animationCurve = null, CoordinateSpaceType coordinateSpace = CoordinateSpaceType.Global, Action <TransitionStep> onStart = null, Action <TransitionStep> onUpdate = null, Action <TransitionStep> onComplete = null) { Target = target; Delay = delay; Duration = duration; TransitionMode = transitionMode; TimeUpdateMethod = timeUpdateMethod; TweenType = tweenType; AnimationCurve = animationCurve ?? AnimationCurve.EaseInOut(0, 0, 1, 1); CoordinateSpace = coordinateSpace; AddOnStartAction(onStart); AddOnUpdateAction(onUpdate); AddOnCompleteAction(onComplete); }
private void Awake() { lightSource = gameObject.AddComponent <Light>(); lightSource.range = Radius; lightSource.intensity = LightCurve.Evaluate(0); var ps = gameObject.GetComponent <ParticleSystem>(); mat = ps.GetComponent <Renderer>().sharedMaterial; var color = mat.GetColor("_TintColor"); var max = Mathf.Max(color.r, Mathf.Max(color.g, color.b)); color.r = Mathf.Clamp01(color.r / max); color.g = Mathf.Clamp01(color.g / max); color.b = Mathf.Clamp01(color.b / max); color.a = 1; lightSource.color = color; #if UNITY_5_3 //timeDuration = UseDurationFromParticleSystem? ps.startLifetime : Duration; var usedRate = ps.emission.rate.constantMax > 0 ? true : false; timeDuration = !usedRate ? ps.startLifetime : ps.startLifetime + ps.duration; isLoop = ps.loop; #else //timeDuration = UseDurationFromParticleSystem ? ps.main.startLifetime.constantMax : Duration; var usedRate = ps.emission.rateOverTime.constantMax > 0 ? true : false; timeDuration = !usedRate ? ps.main.startLifetime.constantMax : ps.main.startLifetime.constantMax + ps.main.duration; isLoop = ps.main.loop; #endif if (isLoop) { LightCurve = AnimationCurve.EaseInOut(0, 1, 1, 1); } }
private void AddAnimationMoveToPlayerDeck(Vector3 endPosition) { var clip = new AnimationClip(); var curve = AnimationCurve.EaseInOut(0, transform.position.x, 1, endPosition.x); clip.SetCurve("", typeof(Transform), "localPosition.x", curve); curve = AnimationCurve.EaseInOut(0, transform.position.y, 0.7f, 0f); clip.SetCurve("", typeof(Transform), "localPosition.y", curve); curve = new AnimationCurve(); curve.AddKey(0, transform.position.z); var keyframe = curve[0]; keyframe.outTangent = 1; curve.MoveKey(0, keyframe); curve.AddKey(0.4f, transform.position.z - 2.5f); curve.AddKey(0.70f, transform.position.z - 4.7f); curve.AddKey(1f, endPosition.z); keyframe = curve[3]; keyframe.inTangent = 0; curve.MoveKey(3, keyframe); clip.SetCurve("", typeof(Transform), "localPosition.z", curve); clip.wrapMode = WrapMode.Once; var animEv = new AnimationEvent(); animEv.functionName = "animFinished"; animEv.time = clip.length; clip.AddEvent(animEv); clip.legacy = true; GetComponent <Animation>().AddClip(clip, "MoveToPlayerDeckAnimation"); }
// Token: 0x06000823 RID: 2083 RVA: 0x00028A78 File Offset: 0x00026C78 public override void OnExit() { if (base.characterBody && NetworkServer.active) { if (base.characterBody.HasBuff(BuffIndex.Cloak)) { base.characterBody.RemoveBuff(BuffIndex.Cloak); } if (base.characterBody.HasBuff(BuffIndex.CloakSpeed)) { base.characterBody.RemoveBuff(BuffIndex.CloakSpeed); } } if (!this.outer.destroying) { this.CastSmoke(); } if (CastSmokescreenNoDelay.destealthMaterial) { TemporaryOverlay temporaryOverlay = this.animator.gameObject.AddComponent <TemporaryOverlay>(); temporaryOverlay.duration = 1f; temporaryOverlay.destroyComponentOnEnd = true; temporaryOverlay.originalMaterial = CastSmokescreenNoDelay.destealthMaterial; temporaryOverlay.inspectorCharacterModel = this.animator.gameObject.GetComponent <CharacterModel>(); temporaryOverlay.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f); temporaryOverlay.animateShaderAlpha = true; } base.OnExit(); }
IEnumerator scaleOutPanel(float duration) { SetPivot(panelRect, new Vector2(0.5f, 0f)); float startHeight = panelRect.sizeDelta.y; float endHeight = 0.0f; float startWidth = panelRect.sizeDelta.y; float endWidth = 0.0f; float time = 0.0f; AnimationCurve heightCurve = AnimationCurve.EaseInOut(time, startHeight, duration, endHeight); AnimationCurve widthCurve = AnimationCurve.EaseInOut(time, startWidth, duration, endWidth); while (time < duration) { float currentHeight = heightCurve.Evaluate(time); float currentWidth = widthCurve.Evaluate(time); panelRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, currentHeight); panelRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, currentWidth); yield return(null); time += Time.deltaTime; } panelRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, endHeight); panelRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, endWidth); SetPivot(panelRect, new Vector2(0.5f, 0.5f)); destroyMe(); }
public void Init(float duration, float deltaHeight) { curve = AnimationCurve.EaseInOut(0, 0, 1, 1); base.duration = duration; this.deltaHeight = deltaHeight; delay = 0; }
IEnumerator CreateLine2() { var sp = new SplineParams(); sp.spline = new BezierSpline2D( RV(), RV(), RV(), RV()); sp.spline.AddCurve(RV(), RV(), RV()); sp.spline.AddCurve(RV(), RV(), RV()); sp.spline.AddCurve(RV(), RV(), RV()); sp.color = Color.Lerp(blue, red, Random.value).WithAlpha(0); sp.width = Random.Range(0.02f, 0.2f); Animatable2[] anims = NoteFactory.CreateLine(sp); foreach (var l in anims) { l.AddAnimationCurve(AnimationKeyPath.Opacity, AnimationCurve.Linear(0, 0, 1, 1)); yield return(new WaitForSeconds(0.01f)); } yield return(new WaitForSeconds(2f)); foreach (var l in anims) { //l.velocity = RandomHelper.RandomVector2(-0.5f, 0.5f, -0.5f, 0.5f); //l.angularVelocity = Random.Range(-90f, 90f); l.AddAnimationCurve(AnimationKeyPath.Opacity, AnimationCurve.EaseInOut(0, 1, 3, 0)); l.DestroyIn(4f); } }
/// <Summary> /// Completely overwrites AudioSourceParameters of a Sound to any value. /// Only use this if you have a known entry for all parameters, otherwise the sound will /// not play properly (eg, having no entry for pitch will make the sound never start or finish) /// </Summary> private static void ForceAudioSourceParameters(AudioSourceParameters audioSourceParameters, SoundSpawn soundSpawn) { AudioSource audioSource = soundSpawn.AudioSource; audioSource.volume = audioSourceParameters.Volume; audioSource.pitch = audioSourceParameters.Pitch; audioSource.time = audioSourceParameters.Time; audioSource.panStereo = audioSourceParameters.Pan; audioSource.spatialBlend = audioSourceParameters.SpatialBlend; audioSource.minDistance = audioSourceParameters.MinDistance; audioSource.maxDistance = audioSourceParameters.MaxDistance; audioSource.spread = audioSourceParameters.Spread; audioSource.outputAudioMixerGroup = Instance.CalcAudioMixerGroup(audioSourceParameters.MixerType); switch (audioSourceParameters.VolumeRolloffType) { case VolumeRolloffType.EaseInAndOut: audioSource.rolloffMode = AudioRolloffMode.Custom; audioSource.SetCustomCurve(AudioSourceCurveType.CustomRolloff, AnimationCurve.EaseInOut(0, 1, 1, 0)); break; case VolumeRolloffType.Linear: audioSource.rolloffMode = AudioRolloffMode.Linear; break; case VolumeRolloffType.Logarithmic: audioSource.rolloffMode = AudioRolloffMode.Logarithmic; break; } }
/// <summary> /// Reset parameters to their default state. /// </summary> void Reset() { Progress = 0; Duration = 0.5f; TweenType = TransitionHelper.TweenType.linear; AnimationCurve = AnimationCurve.EaseInOut(0, 0, 1, 1); }
public void Update() { if (!renderer) { if (itemFollower && itemFollower.followerInstance) { renderer = itemFollower.followerInstance.GetComponentInChildren <Renderer>(); } } if (blinkTimer > 0f) { blinkTimer -= Time.deltaTime; if (blinkTimer <= 0f) { if (renderer) { renderer.shadowCastingMode = ShadowCastingMode.On; renderer.enabled = true; EffectManager.SpawnEffect(blinkEffect, new EffectData { origin = renderer.transform.position }, false); TemporaryOverlay temporaryOverlay = renderer.gameObject.AddComponent <TemporaryOverlay>(); temporaryOverlay.duration = flashTimer = flashDuration; temporaryOverlay.destroyObjectOnEnd = false; temporaryOverlay.destroyComponentOnEnd = true; temporaryOverlay.originalMaterial = materialFlash; temporaryOverlay.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f); temporaryOverlay.animateShaderAlpha = true; temporaryOverlay.SetupMaterial(); var materials = renderer.materials; HG.ArrayUtils.ArrayAppend(ref materials, temporaryOverlay.materialInstance); renderer.materials = materials; materialInstance = renderer.materials.Last(); } } } if (flashTimer > 0f) { flashTimer -= Time.deltaTime; if (flashTimer <= 0f) { if (renderer && materialInstance) { var materials = renderer.materials; var index = System.Array.IndexOf(materials, materialInstance); if (index != -1) { HG.ArrayUtils.ArrayRemoveAtAndResize(ref materials, index); } renderer.materials = materials; } } } }