Tween cancellation using CancellationToken?

[Karabaev]

I would like to cancel Tween/Sequence using CancellationToken. Is there any way to do that?

[KyryloKuzyk]

Hey! There is currently no CancellationToken support in PrimeTween. Instead, PrimeTween offers a simple tween/sequence.Stop() method that can cancel animations, including those awaited with 'await'.

Can you please provide an example in which use cases you would like to use CancellationToken together with PrimeTween?

Similar threads:
#54
#46

[Karabaev]

Sorry for late reply.

I have a class AnimatedObject, which is attached to an animated element. It has one public method StartAnimationAsync, which starts the animation.

Also there is a class AnimatedObjectSpawner, which gets an instance of the AnimatedObject class (from a pool), and calls its StartAnimationAsync method. It waits for the completion and returns the instance to the pool. The AnimatedObjectSpawner class subscribes to a certain external event.
When this event occurs, it is necessary to interrupt the animation and return the object with the AnimatedObject class to the pool.

Example methods in AnimatedObjectSpawner:

void OnSomeEventRaised()
{
    _cts.Cancel();    
}

async UniTask SpawnAnimatedObject()
{
    AnimatedObject instance = pool.Get();
    await instance.StartAnimationAsync(_cts.Token);
    pool.Return(instance);
}

It would be possible to add an AnimatedObject.Interrupt method, which would wrap Tween.Stop. However, to call AnimatedObject.Interrupt, a reference to AnimatedObject would need to be stored in a field.

However, by code design, it would be better to pass a CancellationToken, as in the example above.

Hope I managed to provide you a clear example :)

[KyryloKuzyk]

Great example, thank you!

If the only async operation that happens inside SpawnAnimatedObject() is animation, then it should be possible to do something like this. Or do you want to combine multiple async operations under one CancellationTokenSource?

Tween/Sequence _animation;

void OnSomeEventRaised()
{
    _animation.Stop();
}

async UniTask SpawnAnimatedObject()
{
    AnimatedObject instance = pool.Get();
    _animation = instance.StartAnimation();
    await _animation;
    pool.Return(instance);
}

[kyubuns]

I want to use PrimeTween in combination with R3(+UniTask) (the successor to UniRx).
https://github.com/Cysharp/R3

I want to write the following code.

var rp = new ReactiveProperty<float>(10.0f);
rp.SubscribeAwait(async (x, ct) =>
{
    await Tween.Scale(target, x, 1.0f).ToYieldInstruction().WithCancellation(cancellationToken: ct);
}, AwaitOperation.Switch);

However, with this, the tween will continue to run even if the CancellationToken is canceled.
I know that I can do it in the following way,

var rp = new ReactiveProperty<float>(10.0f);
Tween tween = default;
rp.Subscribe(x =>
{
    tween.Stop();
    tween = Tween.Scale(target, x, 1.0f);
});

but I simply prefer the example first.

---

I understood the design concept of PrimeTween by reading #46.
I want to create a convenient extension method for my project.
But, in the code below, the class new runs every time it is called. (In Disposable.Create.)
Does anyone know a more efficient method?

public static class PrimeTweenExtensions
{
    public static UniTask ToTask(this Tween tween, CancellationToken cancellationToken = default)
    {
        Disposable.Create(tween.Stop).AddTo(cancellationToken);
        return tween.ToYieldInstruction().ToUniTask(cancellationToken: cancellationToken);
    }
}

var rp = new ReactiveProperty<float>(10.0f);
rp.SubscribeAwait(async (x, ct) =>
{
    await Tween.Scale(target, x, 1.0f).ToTask(ct);
}, AwaitOperation.Switch);

[kyubuns]

This code seems better because it doesn't cause a new class to be created.
I'm not very familiar with C#. I'd like to hear the opinions of people who are familiar with it.

public static class PrimeTweenExtensions
{
    public static UniTask ToTask(this Tween tween, CancellationToken cancellationToken = default)
    {
        new TweenDisposable(tween).AddTo(cancellationToken);
        return tween.ToYieldInstruction().ToUniTask(cancellationToken: cancellationToken);
    }

    private readonly struct TweenDisposable : IDisposable
    {
        private readonly Tween _tween;

        public TweenDisposable(Tween tween)
        {
            _tween = tween;
        }

        public void Dispose()
        {
            _tween.Stop();
        }
    }
}