private void DoTween(float target) { var floatTween = new FloatTween { duration = _blinkFrequency, startFloat = _canvasGroup.alpha, targetFloat = target }; floatTween.AddOnChangedCallback(SetCanvasAlpha); floatTween.AddOnFinishCallback(() => { _blinkLock = false; }); floatTween.ignoreTimeScale = true; floatTween.easing = TweenEasing.Linear; this._floatTweenRunner.StartTween(floatTween); }
Widget _buildFixedLabel() { float t = new FloatTween( begin: BottomNavigationBarUtils._kInactiveFontSize / BottomNavigationBarUtils._kActiveFontSize, end: 1.0f ).evaluate(this.animation); return(new Align( alignment: Alignment.bottomCenter, heightFactor: 1.0f, child: new Container( margin: EdgeInsets.only(bottom: BottomNavigationBarUtils._kBottomMargin), child: DefaultTextStyle.merge( style: new TextStyle( fontSize: BottomNavigationBarUtils._kActiveFontSize, color: this.colorTween.evaluate(this.animation) ), // child: new Transform( // transform: Matrix3.makeAll(t, 0, 0, 0, t, 0, 0, 0, t), // alignment: Alignment.bottomCenter, // child: this.item.title // ) child: this.item.title ) ) )); }
public override Widget build(BuildContext context) { float t = new FloatTween( begin: BottomNavigationBarUtils._kInactiveFontSize / BottomNavigationBarUtils._kActiveFontSize, end: 1.0f ).evaluate(this.animation); return(new Align( alignment: Alignment.bottomCenter, heightFactor: 1.0f, child: new Container( margin: EdgeInsets.only(bottom: BottomNavigationBarUtils._kBottomMargin), child: DefaultTextStyle.merge( style: new TextStyle( fontSize: BottomNavigationBarUtils._kActiveFontSize, color: this.colorTween.evaluate(this.animation) ), child: new Transform( transform: Matrix3.makeScale(t), alignment: Alignment.bottomCenter, child: this.item.title ) ) ) )); }
public override void paint( PaintingContext context, Offset center, Animation <float> activationAnimation = null, Animation <float> enableAnimation = null, bool?isDiscrete = null, TextPainter labelPainter = null, RenderBox parentBox = null, SliderThemeData sliderTheme = null, float?value = null ) { Canvas canvas = context.canvas; FloatTween radiusTween = new FloatTween( begin: 0.0f, end: this.overlayRadius ); canvas.drawCircle( center, radiusTween.evaluate(activationAnimation), new Paint { color = sliderTheme.overlayColor } ); }
public static FloatTween TweenAlpha(this CanvasGroup obj, float duration, float from, float to) { FloatTween node = FloatTween.Allocate(duration, from, to); node.SetUpdate((result) => { obj.alpha = result; }); return(node); }
private void StartAlphaTween(float targetAlpha, float duration, TweenEasing easing) { if (this.m_CanvasGroup == null) { return; } // Check if currently transitioning if (this.m_Transitioning) { this.m_FloatTweenRunner.StopTween(); } if (duration == 0f || !Application.isPlaying) { this.SetAlpha(targetAlpha); } else { this.m_Transitioning = true; var floatTween = new FloatTween { duration = duration, startFloat = this.m_CanvasGroup.alpha, targetFloat = targetAlpha }; floatTween.AddOnChangedCallback(SetAlpha); floatTween.ignoreTimeScale = true; floatTween.easing = easing; floatTween.AddOnFinishCallback(OnTweenFinished); this.m_FloatTweenRunner.StartTween(floatTween); } }
protected override Widget buildStackActions(BuildContext context, CustomDismissibleDelegateContext ctx) { return(Positioned.fill( new LayoutBuilder(builder: (_context, constraints) => { var totalExtent = ctx.getMaxExtent(constraints) * ctx.state.totalActionsExtent; var animation = new FloatTween(-totalExtent, 0).animate(ctx.state.actionsMoveAnimation); return new AnimatedBuilder( animation: ctx.state.actionsMoveAnimation, builder: (cxt, child) => { var widgets = new List <Widget>(); ctx.buildActions(cxt).ForEach(item => { var widget = new Expanded(child: item); widgets.Add(widget); }); return new Stack( children: new List <Widget> { ctx.createPositioned( position: animation.value, extent: totalExtent, child: new Flex( ctx.state.widget.direction, children: widgets ) ) } ); } ); }) )); }
// Use this for initialization void Start() { float duration = 5; Tween tween = FloatTween.CreateTween(duration, // Called each update with 'time' being time left. (time) => { // (Optional if needed). // To normalize the time value from 0 - 1. // 0 means tween just started, 1 means tween is dead. float normalized = (1.0f - time / duration); // For testing purposes lets move transform somewhere. Vector3 nextPosition = transform.position + Vector3.up * Mathf.Sin(time * time) * Time.deltaTime * 3; // Set the next position. transform.position = nextPosition; }, // Called at the end of the tween. (Tween dies). () => { Debug.Log("Tween has ended!"); }); // Don't forget to start me. tween.Start(); }
private void TweenMove() { isMoving = true; moveTween = gameObject.Tween("Move" + GetInstanceID(), initialPos, targetPos, getDuration(), TweenScaleFunctions.Linear, (t) => { float pos = t.CurrentValue; if (direction == Direction.xAxis) { Vector3 tmp = transform.position; transform.position = new Vector3(pos, tmp.y, tmp.z); } else { Vector3 tmp = transform.position; transform.position = new Vector3(tmp.x, tmp.y, pos); } }, (t) => { Debug.Log("Finished move."); isMoving = false; }); }
public override void Finish() { if (Finished) return; if (audioSource.audio.isPlaying) { FloatTween volumeFade = new FloatTween(); volumeFade.From = 1.0f; volumeFade.To = 0f; volumeFade.Duration = 750f; volumeFade.CurrentValueChanged += (args) => { audioSource.audio.volume = args.NewValue; if (args.NewValue == 0f) GameObject.Destroy(audioSource); }; TimedTaskManager.Instance.Add(volumeFade); } else { GameObject.Destroy(audioSource); } base.Finish(); }
void _createAnimationController() { this._animationController = new AnimationController(vsync: this, value: 0.5f); FloatTween tween = new FloatTween(0.0f, 1.0f); this._animation = tween.animate(parent: this._animationController); }
public void Start() { if (_button == null) { throw new Exception("MainSceneController::Start - Missing button"); } if (_input == null) { throw new Exception("MainSceneController::Start - Missing input"); } _button.interactable = false; _button.onClick.AddListener(CmdProceed); // _input.text = string.Join(", ", appService.GetEntries()); _random = new System.Random((int)Time.time); ResetColorList(); _input.onSubmit.AddListener(OnSearchFieldSubmitted); _button.interactable = true; // tween setup for button var rtf = _button.GetComponent <RectTransform>(); buttonTween = new FloatTween(); buttonTween.Start(-40, -200, 0.6f, ScaleFuncs.SineEaseInOut); }
void _createAnimationController() { _animationController = new AnimationController(vsync: this, value: 0.5f); Tween <float> tween = new FloatTween(begin: 0.0f, end: 1.0f); _animation = tween.animate(_animationController); }
private void showScore() { var scoreText = new GameText("+1"); scoreText.position = position; scene.addEntity(scoreText); var moveTween = scoreText.tweenPositionTo(position + new Vector2(0, -40), deathDuration); moveTween.setEaseType(EaseType.QuadOut); moveTween.start(); var opacityTween = new FloatTween(scoreText, 0f, deathDuration - 0.3f); opacityTween.setEaseType(EaseType.QuadOut); opacityTween.setDelay(0.3f); opacityTween.start(); Core.schedule(deathDuration, t => { if (scene != null) { scoreText?.destroy(); } }); }
private bool AnimProperty(FloatTween prop, CameraParameter para, bool chechAngle) { if (para == null || prop == null) { return(false); } float value = para.value; if (chechAngle && para.isAngle) { float pt = prop.To; while (pt > 180f) { pt -= 360f; prop.Value -= 360f; } while (pt < -180f) { pt += 360f; prop.Value += 360f; } while (value - pt > 180f) { value -= 360f; } while (value - pt < -180f) { value += 360f; } } return(para.curve != null? prop.AnimTo(value, para.duration, para.curve) : prop.AnimTo(value, para.duration, para.ease)); }
public static void DrawEquipmentAiming_Prefix(PawnRenderer __instance, Thing eq, Vector3 drawLoc, ref float aimAngle) { Pawn pawn = __instance.graphics.pawn; // Flip the angle for north if (pawn.Rotation == Rot4.North && aimAngle == angleStanding) { aimAngle = angleStandingFlipped; } if (!pawn.GetCompAnim(out CompBodyAnimator animator)) { return; } if (Find.TickManager.TicksGame == animator.LastAngleTick) { aimAngle = animator.LastAimAngle; return; } animator.LastAngleTick = Find.TickManager.TicksGame; float angleChange; float startAngle = animator.LastAimAngle; float endAngle = aimAngle; FloatTween tween = animator.AimAngleTween; switch (tween.State) { case TweenState.Running: startAngle = tween.EndValue; endAngle = aimAngle; aimAngle = tween.CurrentValue; break; } angleChange = CalcShortestRot(startAngle, endAngle); if (Mathf.Abs(angleChange) > 6f) { // no tween for flipping bool x = Mathf.Abs(animator.LastAimAngle - angleStanding) < 3f && Mathf.Abs(aimAngle - angleStandingFlipped) < 3f; bool y = Mathf.Abs(animator.LastAimAngle - angleStandingFlipped) < 3f && Mathf.Abs(aimAngle - angleStanding) < 3f; bool z = Math.Abs(Mathf.Abs(aimAngle - animator.LastAimAngle) - 180f) < 12f; if (!x && !y && !z) { // if (Math.Abs(aimAngleTween.EndValue - weaponAngle) > 6f) tween.Start(startAngle, startAngle + angleChange, Mathf.Abs(angleChange), ScaleFuncs.QuinticEaseOut); aimAngle = startAngle; } } animator.LastAimAngle = aimAngle; }
public _ChildAnimationManifest( float opacity = 1f, float separatorOpacity = 0f ) { separatorTween = new FloatTween(begin: separatorOpacity, end: separatorOpacity); opacityTween = new FloatTween(begin: opacity, end: opacity); }
private void Awake() { rend = GetComponent <SpriteRenderer>(); tween = new FloatTween(); tweenTarget = new Crystal.FlashTweenTarget(rend); tween.setRecycleTween(false); }
protected override void forEachTween(TweenVisitor visitor) { this._elevation = (FloatTween)visitor.visit(this, this._elevation, this.widget.elevation, (float value) => new FloatTween(begin: value, end: value)); this._shadowColor = (ColorTween)visitor.visit(this, this._shadowColor, this.widget.shadowColor, (Color value) => new ColorTween(begin: value)); this._border = (ShapeBorderTween)visitor.visit(this, this._border, this.widget.shape, (ShapeBorder value) => new ShapeBorderTween(begin: value)); }
public static async UniTask SetHourAsync(float hour, float duration, AsyncToken token = default) { if (tweener.Running) { tweener.CompleteInstantly(); } var tween = new FloatTween(CurrentHour, hour, duration, SetHour); await tweener.RunAsync(tween, token, target : instance); }
public _ChildAnimationManifest( float opacity = 1f, float separatorOpacity = 0f) { D.assert(separatorOpacity != null); D.assert(opacity != null); separatorTween = new FloatTween(begin: separatorOpacity, end: separatorOpacity); opacityTween = new FloatTween(begin: opacity, end: opacity); }
private void Update() { if (!sk.backgroundSound.audioSource.isPlaying) { // if (!triggered) // { // triggered = true; // // } foreach (Animator animator in treeAnimators) { animator.SetTrigger("Dying"); } foreach (Animator animator in grassAnimators) { animator.SetTrigger("Dying"); } FloatTween tween = new FloatTween(tweenTarget, 1.0f, 5.0f, 3.0f); tween.start(); sk.playBackgroundMusic(clip, 1.0f, false); // gameObject.SetActive(false); rock.mass = rockMass; sissyphusMovement.InputDisabled = true; StartCoroutine(CoroutineUtils.DelaySeconds(() => { rock.mass = 1f; sissyphusMovement.InputDisabled = false; sissyphusMovement.MaxMoveSpeed = maxMoveSpeed; sissyphusMovement.MaxButtonBoost = maxButtonBoost; FloatTween tween2 = new FloatTween(tweenTarget, 5.0f, 1.0f, 3.0f); tween2.start(); foreach (Animator animator in treeAnimators) { animator.SetTrigger("Alive"); } foreach (Animator animator in grassAnimators) { animator.SetTrigger("Alive"); } }, 11f)); // ITween<float> tween = PropertyTweens.floatPropertyTo(this, "atmosphereThickness", 5, 3.0f); // tween.start(); // float atmosphereThickness = 1f; } // atmosphereThickness = Mathf.Clamp(atmosphereThickness, 0f, 5f); // skyboxMaterial.SetFloat("_AtmosphereThickness", atmosphereThickness); }
public async UniTask AwaitSpawnAsync(CancellationToken cancellationToken = default) { if (intensityTweener.Running) { intensityTweener.CompleteInstantly(); } var tween = new FloatTween(0, Intensity, FadeInTime, SetIntensity, target: particles); await intensityTweener.RunAsync(tween, cancellationToken); }
private void Awake() { rb2d = GetComponent <Rigidbody2D>(); rend = GetComponent <SpriteRenderer>(); hp = maxHp; tween = new FloatTween(); tweenTarget = new Crystal.FlashTweenTarget(rend); tween.setRecycleTween(false); }
public async Task AwaitSpawnAsync(CancellationToken cancellationToken = default) { if (intensityTweener.IsRunning) { intensityTweener.CompleteInstantly(); } var tween = new FloatTween(emissionModule.rateOverTimeMultiplier, Intensity, FadeInTime, SetIntensity); await intensityTweener.RunAsync(tween, cancellationToken); }
public async UniTask AwaitDestroyAsync(CancellationToken cancellationToken = default) { if (intensityTweener.Running) { intensityTweener.CompleteInstantly(); } var tween = new FloatTween(Intensity, 0, FadeOutTime, SetTintOpacity, target: particles); await intensityTweener.RunAsync(tween, cancellationToken); }
public async UniTask AwaitDestroyAsync(CancellationToken cancellationToken = default) { if (intensityTweener.Running) { intensityTweener.CompleteInstantly(); } var tween = new FloatTween(emissionModule.rateOverTimeMultiplier, 0, FadeOutTime, SetIntensity, target: particles); await intensityTweener.RunAsync(tween, cancellationToken); }
private void Awake() { rend = GetComponent <SpriteRenderer>(); anim = GetComponent <Animator>(); tween = new FloatTween(); tweenTarget = new FlashTweenTarget(rend); // tween.initialize(tweenTarget, 0f, 1f); // tween.setFrom(1f); tween.setRecycleTween(false); }
public async UniTask AwaitSpawnAsync(CancellationToken cancellationToken = default) { if (intensityTweener.Running) { intensityTweener.CompleteInstantly(); } var time = cancellationToken.CancelLazy ? 0 : FadeInTime; var tween = new FloatTween(emissionModule.rateOverTimeMultiplier, Intensity, time, SetRateOverTime, target: particles); await intensityTweener.RunAsync(tween, cancellationToken); }
public void OnPointerExit(PointerEventData e) { var floatTween = new FloatTween { duration = Duration, startFloat = Rect.anchoredPosition.y, targetFloat = OriginalPosition.y }; floatTween.AddOnChangedCallback(UpdateYPosition); Runner.StartTween(floatTween); }
public void Deactivate() { var tween = new FloatTween { duration = this.m_TweenDuration, startFloat = this.m_CanvasGroup.alpha, targetFloat = this.m_InactiveAlpha }; tween.AddOnChangedCallback(SetAlpha); tween.ignoreTimeScale = true; this.m_TweenRunner.StartTween(tween); }
protected override void forEachTween(TweenVisitor visitor) { this._borderRadius = (BorderRadiusTween)visitor.visit(this, this._borderRadius, this.widget.borderRadius, (BorderRadius value) => new BorderRadiusTween(begin: value)); this._elevation = (FloatTween)visitor.visit(this, this._elevation, this.widget.elevation, (float value) => new FloatTween(begin: value, end: value)); this._color = (ColorTween)visitor.visit(this, this._color, this.widget.color, (Color value) => new ColorTween(begin: value)); this._shadowColor = (ColorTween)visitor.visit(this, this._shadowColor, this.widget.shadowColor, (Color value) => new ColorTween(begin: value)); }
protected void StartTween(float targetFloat, float duration) { if (this.imageComponent == null) return; var floatTween = new FloatTween { duration = duration, startFloat = this.imageComponent.fillAmount, targetFloat = targetFloat }; floatTween.AddOnChangedCallback(SetFillAmount); floatTween.AddOnFinishCallback(OnTweenFinished); floatTween.ignoreTimeScale = true; floatTween.easing = this.Easing; this.m_FloatTweenRunner.StartTween(floatTween); }
public void StartDemoTween() { if (this.bar == null) return; float pct = (float)this.bar.value / (float)this.bar.maxValue; float targetAmount = (pct > 0.5f) ? 0f : 1f; FloatTween floatTween = new FloatTween { duration = this.duration, startFloat = pct, targetFloat = targetAmount }; floatTween.AddOnChangedCallback(SetFillAmount); floatTween.AddOnFinishCallback(OnTweenFinished); floatTween.ignoreTimeScale = true; this.m_FloatTweenRunner.StartTween(floatTween); }
protected void Start() { if (this.imageComponent != null) this.imageComponent.fillAmount = 0f; if (this.textComponent != null) this.textComponent.text = "0%"; var floatTween = new FloatTween { duration = this.Duration, startFloat = 0f, targetFloat = 1f }; floatTween.AddOnChangedCallback(SetFillAmount); floatTween.AddOnFinishCallback(OnTweenFinished); floatTween.ignoreTimeScale = true; this.m_FloatTweenRunner.StartTween(floatTween); }
/// <summary> /// Raises the bar fill change event. /// </summary> /// <param name="amount">Amount.</param> public void OnBarFillChange(float amount) { // Calculate the bar fill based on it's width and value float fillWidth = ((float)this.bar.imageComponent.rectTransform.rect.width * this.bar.imageComponent.fillAmount); // Check if the fill width is too small to bother with the ending if (fillWidth <= (1f + (float)this.offset)) { this.targetImage.gameObject.SetActive(false); return; } else if (!this.targetImage.gameObject.activeSelf) { // Re-enable this.targetImage.gameObject.SetActive(true); } // Position the ending at the end of the fill this.targetImage.rectTransform.anchoredPosition = new Vector2( (this.offset + fillWidth), this.targetImage.rectTransform.anchoredPosition.y ); // Check if the fill width is too great to handle the ending width if (fillWidth < this.defaultFinishWidth) { // Change the width to the fill width this.targetImage.rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, Mathf.Round(fillWidth)); } else if (this.targetImage.rectTransform.rect.width != this.defaultFinishWidth) { // Restore default width this.targetImage.rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, this.defaultFinishWidth); } // Show / Hide the finish if (this.autoVisibility) { // Check if the finish needs the be shown if (this.bar.imageComponent.fillAmount >= this.showAfterPct && this.bar.imageComponent.fillAmount < this.hideAfterPct) { // Fade in if not 100% if (this.fading) { FloatTween floatTween = new FloatTween { duration = this.fadeDuration, startFloat = this.canvasGroup.alpha, targetFloat = this.defaultFinishAlpha }; floatTween.AddOnChangedCallback(SetFinishAlpha); floatTween.ignoreTimeScale = true; this.m_FloatTweenRunner.StartTween(floatTween); } else this.SetFinishAlpha(this.defaultFinishAlpha); } else if (this.bar.imageComponent.fillAmount >= this.hideAfterPct || this.bar.imageComponent.fillAmount < this.showAfterPct) { // Fade out at 100% if (this.fading) { FloatTween floatTween = new FloatTween { duration = this.fadeDuration, startFloat = this.canvasGroup.alpha, targetFloat = 0f }; floatTween.AddOnChangedCallback(SetFinishAlpha); floatTween.ignoreTimeScale = true; this.m_FloatTweenRunner.StartTween(floatTween); } else this.SetFinishAlpha(0f); } } }
/// <summary> /// Starts a alpha tween on the tooltip. /// </summary> /// <param name="targetAlpha">Target alpha.</param> public void StartAlphaTween(float targetAlpha, float duration) { var floatTween = new FloatTween { duration = duration, startFloat = this.m_CanvasGroup.alpha, targetFloat = targetAlpha }; floatTween.AddOnChangedCallback(SetAlpha); floatTween.AddOnFinishCallback(OnTweenFinished); floatTween.ignoreTimeScale = true; floatTween.easing = this.m_TransitionEasing; this.m_FloatTweenRunner.StartTween(floatTween); }
/// <summary> /// Starts alpha tween. /// </summary> /// <param name="targetAlpha">Target alpha.</param> /// <param name="duration">Duration.</param> /// <param name="ignoreTimeScale">If set to <c>true</c> ignore time scale.</param> public void StartAlphaTween(float targetAlpha, float duration, bool ignoreTimeScale) { if (this.m_CanvasGroup == null) return; var floatTween = new FloatTween { duration = duration, startFloat = this.m_CanvasGroup.alpha, targetFloat = targetAlpha }; floatTween.AddOnChangedCallback(SetCanvasAlpha); floatTween.AddOnFinishCallback(OnHideTweenFinished); floatTween.ignoreTimeScale = ignoreTimeScale; this.m_FloatTweenRunner.StartTween(floatTween); }
/// <summary> /// Tweens the canvas group alpha. /// </summary> /// <param name="targetAlpha">Target alpha.</param> /// <param name="duration">Duration.</param> /// <param name="ignoreTimeScale">If set to <c>true</c> ignore time scale.</param> private void StartAlphaTween(float targetAlpha, float duration, bool ignoreTimeScale) { if (this.m_Group == null) return; float currentAlpha = this.m_Group.alpha; if (currentAlpha.Equals(targetAlpha)) return; var floatTween = new FloatTween { duration = duration, startFloat = currentAlpha, targetFloat = targetAlpha }; floatTween.AddOnChangedCallback(SetAlpha); floatTween.AddOnFinishCallback(OnTweenFinished); floatTween.ignoreTimeScale = ignoreTimeScale; floatTween.easing = this.m_Easing; this.m_FloatTweenRunner.StartTween(floatTween); }
protected void StartTween(float startFloat, float targetFloat) { float duration = (this.m_Accordion != null) ? this.m_Accordion.transitionDuration : 0.3f; FloatTween info = new FloatTween { duration = duration, startFloat = startFloat, targetFloat = targetFloat }; info.AddOnChangedCallback(SetHeight); info.ignoreTimeScale = true; this.m_FloatTweenRunner.StartTween(info); }
/// <summary> /// Tweens the delete button alpha. /// </summary> /// <param name="targetAlpha">Target alpha.</param> /// <param name="duration">Duration.</param> /// <param name="ignoreTimeScale">If set to <c>true</c> ignore time scale.</param> public void TweenDeleteButtonAlpha(float targetAlpha, float duration, bool ignoreTimeScale) { if (this.GetDeleteButtonCavnasGroup() == null) return; float currentAlpha = this.GetDeleteButtonCavnasGroup().alpha; if (currentAlpha.Equals(targetAlpha)) return; var floatTween = new FloatTween { duration = duration, startFloat = currentAlpha, targetFloat = targetAlpha }; floatTween.AddOnChangedCallback(SetDeleteButtonAlpha); floatTween.ignoreTimeScale = ignoreTimeScale; this.m_FloatTweenRunner.StartTween(floatTween); }