force blend states to keepGoing

makes blend states keepGoing!

fixes a regression introduced when looking at keep going of states when deciding if to advance them. for blend states specifically mixing is done as well as animating animation instances, and if the mix value changes we need to apply this change.

@luigi-rosso struggled to build state machines into an automated test on the cpp side before. going to add one loading a `.riv` for this I think, at least to cover some basics here.

btw, I assume we also want this behaviour for direct blend states

https://2dimensions.slack.com/archives/CHMAP278R/p1677820699177779

Diffs=
2504d2ab2 force blend states to keepGoing (#4922)

.rive_head

diff --git a/.rive_head b/.rive_head
index 3727ac5..1f1cfee 100644
--- a/.rive_head
+++ b/.rive_head
@@ -1 +1 @@
-bc6c6f467b8f1e0f794be093a514768bd068088a
+2504d2ab24d258621fc89a0120c794f2b53a2ffc

include/rive/animation/blend_state_instance.hpp

diff --git a/include/rive/animation/blend_state_instance.hpp b/include/rive/animation/blend_state_instance.hpp
index 0311f01..9f035cb 100644
--- a/include/rive/animation/blend_state_instance.hpp
+++ b/include/rive/animation/blend_state_instance.hpp
@@ -54,12 +54,15 @@
 
     void advance(float seconds, Span<SMIInput*>) override
     {
-        m_KeepGoing = false;
+        // NOTE: we are intentionally ignoring the animationInstances' keepGoing
+        // return value.
+        // Blend states need to keep blending forever, as even if the animation
+        // does not change the mix values may
         for (auto& animation : m_AnimationInstances)
         {
-            if (animation.m_AnimationInstance.advance(seconds))
+            if (animation.m_AnimationInstance.keepGoing())
             {
-                m_KeepGoing = true;
+                animation.m_AnimationInstance.advance(seconds);
             }
         }
     }

include/rive/animation/linear_animation_instance.hpp

diff --git a/include/rive/animation/linear_animation_instance.hpp b/include/rive/animation/linear_animation_instance.hpp
index 3e645ab..a086dce 100644
--- a/include/rive/animation/linear_animation_instance.hpp
+++ b/include/rive/animation/linear_animation_instance.hpp
@@ -69,6 +69,11 @@
     // (oneShot), reached the end (loop), or changed direction (pingPong)
     bool didLoop() const { return m_DidLoop; }
 
+    bool keepGoing() const
+    {
+        return m_LoopValue != static_cast<int>(rive::Loop::oneShot) || !m_DidLoop;
+    }
+
     float totalTime() const { return m_TotalTime; }
     float lastTotalTime() const { return m_LastTotalTime; }
     float spilledTime() const { return m_SpilledTime; }

test/assets/oneshotblend.riv

diff --git a/test/assets/oneshotblend.riv b/test/assets/oneshotblend.riv
new file mode 100644
index 0000000..2ed610b
--- /dev/null
+++ b/test/assets/oneshotblend.riv
Binary files differ

test/state_machine_test.cpp

diff --git a/test/state_machine_test.cpp b/test/state_machine_test.cpp
index 7f20e6d..7ebd3a0 100644
--- a/test/state_machine_test.cpp
+++ b/test/state_machine_test.cpp
@@ -171,3 +171,29 @@
     auto abi = artboard->instance();
     rive::StateMachineInstance(stateMachine, abi.get()).advance(0.0f);
 }
+
+TEST_CASE("1D blend state keeps keepsGoing true even when animations themselves have stopped",
+          "[file]")
+{
+    auto file = ReadRiveFile("../../test/assets/oneshotblend.riv");
+
+    auto artboard = file->artboard();
+    auto stateMachine = artboard->stateMachine("State Machine 1");
+
+    auto abi = artboard->instance();
+    rive::StateMachineInstance* stateMachineInstance =
+        new rive::StateMachineInstance(stateMachine, abi.get());
+    stateMachineInstance->advance(0.0f);
+    REQUIRE(stateMachineInstance->needsAdvance() == true);
+
+    // after advancing into the 1DBlendState we still need to keep going.
+    stateMachineInstance->advance(0.5f);
+    REQUIRE(stateMachineInstance->needsAdvance() == true);
+
+    // even after advancing past the duration of the animations in the blend states
+    // we need to keep going.
+    stateMachineInstance->advance(1.0f);
+    REQUIRE(stateMachineInstance->needsAdvance() == true);
+
+    delete stateMachineInstance;
+}