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);
}
