Prevent repainting Artboards that are marked inactive by Rive

[mchagneux]

@kunitoki this is Opus 5.5 answer to me asking what we could do to optimize an Artboard

The current code (YUP at edf27f68) does three things in sequence that together stop an artboard from ever being redrawn on demand.

1. The render loop only paints dirty areas. Every tick, the render thread asks every component to refresh, then paints only if something called repaint() (modules/yup_gui/native/yup_Windowing_sdl.cpp:1284-1301):

component.internalRefreshDisplay (currentTimeSeconds - lastRenderTimeSeconds);  // every tick
...
if (renderContinuous)
    repaint();
...
if (! renderContinuous && repaintAreas.isEmpty())
    return false;   // nothing dirty: no paint, no present

2. Artboard::refreshDisplay advances the scene but never marks itself dirty (modules/yup_gui/artboard/yup_Artboard.cpp:881-887, :372-377, :1269-1279):

void Artboard::refreshDisplay (double lastFrameTimeSeconds)
{
    if (paused || (pauseWhenHidden && ! isShowing()))
        return;
    advanceAndApply (static_cast<float> (lastFrameTimeSeconds));   // no repaint()
}

void Artboard::advanceScene (float elapsedSeconds)
{
    ...
    scene->advanceAndApply (elapsedSeconds);   // return value discarded
    pullEventsFromStateMachines();
}

3. Rive already says when a redraw is needed, but YUP discards it:
- rive::Scene::advanceAndApply returns true while the state machine is still animating ("returns true if draw() should be called", thirdparty/rive/include/rive/scene.hpp:49-50).
- rive::Artboard::didChange() (artboard.hpp:449) is set when any component changes and cleared when the artboard draws.

The artboard only calls repaint() after input, setXxxInput, file loads, view-model bind/unbichanges. So in on-demand mode an animation advances every tick but never reaches the screen.

The result: apps have to either turn on withRenderContinuous(true) or override refreshDispla. YUP's graphics example does the latter(examples/graphics/source/examples/Artboard.h:92-95). Either way the window redraws every frame, even when the artboard is completely still. That bypasses YUP's dirty regions and preserved framebuffer, and the
GPU and battery pay for it on mobile.

The fix (a small PR)

Use Rive's signal to decide whether to repaint:

void Artboard::refreshDisplay (double lastFrameTimeSeconds)
{
    if (paused || (pauseWhenHidden && ! isShowing()))
        return;

    if (advanceScene (static_cast<float> (lastFrameTimeSeconds)))   // now returns bool
        repaint();

    notifyNodeBoundsChanged();
}                                                                                                                                                                                                                  
bool Artboard::advanceScene (float elapsedSeconds)                                                                                                                                                                 
    if (scene == nullptr)                                                                                                                                                                                                return false;
                                                                                                                                                                                                                     artboardFile->bindDeferredRecordingThread();
                                                                                                                                                                                                                     const bool keepGoing = scene->advanceAndApply (elapsedSeconds);
    pullEventsFromStateMachines();                                                                                                                                                                                 
    // keepGoing: the state machine is still animating;                                                                                                                                                              // didChange: something changed since the last draw (a data-bound value, a script's dirt
    return keepGoing || (artboard != nullptr && artboard->didChange());                                                                                                                                            
                                                                                                                                                                                                                   e public advanceAndApply(float) could return that bool as well, for callers that drive the
                                                                                                                                                                                                                   y this is safe:
- Advancing still runs every tick, so nothing that depends on it changes. That includes view-model writes made through ArtboardViewModelInstance, which are applied on the next advance; that advance then reports a change and the artboard repaints.
- Inputs already call repaint() themselves.
- For scripted files, paint() records and replays the deferred frame. Skipping paint() when  the previous pixels, which is correct with YUP's preserved framebuffer.
- An app that wants a repaint every frame can still opt into continuous rendering.

Optional follow-up: Rive's own CommandServer stops ticking a state machine entirely once advanceAndApply returns false ("settled"), and resumes on input. YUP could do the same: skip advanceAndApply while
settled, and wake on input, setXxxInput, view-model writes or file loads. That saves the CPU scene too, but it needs every wake-up path covered (view-model writes in particular), soit's better as a second step.

What it gives in practice                                                                                                                                                                                          
A still artboard costs nothing to draw, and only its own bounds are repainted when it changes. That only helps if the content does go still. Rive treats a scene with scripts as busy until each script's advance() returns false. So for our UI, the gain arrives once our scripts stop returning true every fr message).

[kunitoki]

Oh this is nice! I haven't noticed that advanceAndApply is now returning a bool (it wasn't some time ago) ! Will add this, thanks for the heads up!

[kunitoki]

Implemented in #226

[mchagneux]

Awesome

[kunitoki]

I left out the pause and wake on input and events because it could miss repaints if not covering everything correctly.