tests/unit_tests/runtime/data_binding_keyframes.cpp

#include <rive/file.hpp>
#include <rive/viewmodel/viewmodel_instance_string.hpp>
#include <rive/viewmodel/viewmodel_instance_number.hpp>
#include <rive/viewmodel/viewmodel_instance_color.hpp>
#include "rive/animation/state_machine_instance.hpp"
#include "rive/animation/linear_animation_instance.hpp"
#include "rive/nested_artboard.hpp"
#include "rive/text/text_value_run.hpp"
#include "rive/node.hpp"
#include "rive_file_reader.hpp"
#include "utils/serializing_factory.hpp"
#include <catch.hpp>
#include <cstdio>
#include <cstring>

using namespace rive;

// The fixture (assets/data_bind_keyframes_test.riv) plays, via a state machine,
// one animation that keyframes a text run's text and a node's x. Those keyframe
// values are data bound to the default view model: the text run's start/end
// string keyframes bind to `keyfTextStart`/`keyfrTextEnd`, and the node's start
// x keyframe binds to `startX`. At time 0 the start keyframes apply, so the
// bound start values are what land on the targets; the node then tweens from
// the bound start toward its (authored) end.

TEST_CASE("Data binding keyframes", "[silver]")
{
    SerializingFactory silver;
    auto file = ReadRiveFile("assets/data_bind_keyframes_test.riv", &silver);

    auto artboard = file->artboardDefault();
    REQUIRE(artboard != nullptr);

    silver.frameSize(artboard->width(), artboard->height());

    auto stateMachine = artboard->stateMachineAt(0);

    auto vmi = file->createDefaultViewModelInstance(artboard.get());
    auto renderer = silver.makeRenderer();

    stateMachine->bindViewModelInstance(vmi);
    stateMachine->advanceAndApply(0.016f);
    artboard->draw(renderer.get());

    int frames = (int)(1.0f / 0.2f);
    for (int i = 0; i < frames; i++)
    {
        silver.addFrame();
        stateMachine->advanceAndApply(0.2f);
        artboard->draw(renderer.get());
    }

    auto keyfTextStartProp =
        vmi->propertyValue("keyfTextStart")->as<ViewModelInstanceString>();
    keyfTextStartProp->propertyValue("updated--text");

    auto colorStartProp =
        vmi->propertyValue("colorStart")->as<ViewModelInstanceColor>();
    auto yellowColor = (255 << 24) | (255 << 16) | (255 << 8);
    colorStartProp->propertyValue(yellowColor);

    auto startXProp =
        vmi->propertyValue("startX")->as<ViewModelInstanceNumber>();
    startXProp->propertyValue(100);

    for (int i = 0; i < frames; i++)
    {
        silver.addFrame();
        stateMachine->advanceAndApply(0.2f);
        artboard->draw(renderer.get());
    }

    CHECK(silver.matches("data_bind_keyframes_test"));
}

// ---- helpers -------------------------------------------------------------

static TextValueRun* firstTextRun(Artboard* artboard)
{
    auto runs = artboard->find<TextValueRun>();
    return runs.empty() ? nullptr : runs[0];
}

static bool anyNodeHasX(Artboard* artboard, float x)
{
    for (auto* node : artboard->find<Node>())
    {
        if (node->x() == Approx(x))
        {
            return true;
        }
    }
    return false;
}

static void setStartText(rcp<ViewModelInstance> vmi, const std::string& text)
{
    vmi->propertyValue("keyfTextStart")
        ->as<ViewModelInstanceString>()
        ->propertyValue(text);
}

static void setStartX(rcp<ViewModelInstance> vmi, float x)
{
    vmi->propertyValue("startX")->as<ViewModelInstanceNumber>()->propertyValue(
        x);
}

// ---- behavioral tests ----------------------------------------------------

TEST_CASE("keyframe value binds resolve view-model values on the first frame",
          "[data binding]")
{
    auto file = ReadRiveFile("assets/data_bind_keyframes_test.riv");
    auto artboard = file->artboardDefault();
    REQUIRE(artboard != nullptr);
    auto sm = artboard->stateMachineAt(0);
    REQUIRE(sm != nullptr);
    auto vmi = file->createDefaultViewModelInstance(artboard.get());
    REQUIRE(vmi != nullptr);

    // Distinctive sentinels set before binding, so the very first applied frame
    // must reflect them (holders are primed when the data bind is added).
    setStartText(vmi, "SENTINEL_START");
    setStartX(vmi, 424242.0f);

    sm->bindViewModelInstance(vmi);
    sm->advanceAndApply(0.0f);

    auto* run = firstTextRun(artboard.get());
    REQUIRE(run != nullptr);
    CHECK(run->text() == "SENTINEL_START");        // KeyFrameString bind
    CHECK(anyNodeHasX(artboard.get(), 424242.0f)); // KeyFrameDouble bind
}

TEST_CASE("keyframe value binds update when the source view-model changes",
          "[data binding]")
{
    auto file = ReadRiveFile("assets/data_bind_keyframes_test.riv");
    auto artboard = file->artboardDefault();
    REQUIRE(artboard != nullptr);
    auto sm = artboard->stateMachineAt(0);
    auto vmi = file->createDefaultViewModelInstance(artboard.get());

    setStartText(vmi, "first");
    setStartX(vmi, 10.0f);
    sm->bindViewModelInstance(vmi);
    sm->advanceAndApply(0.0f);

    auto* run = firstTextRun(artboard.get());
    REQUIRE(run != nullptr);
    REQUIRE(run->text() == "first");
    REQUIRE(anyNodeHasX(artboard.get(), 10.0f));

    // Change the sources; dt=0 keeps the playhead on the start keyframe, so the
    // exact new bound values must land after the next advance.
    setStartText(vmi, "second");
    setStartX(vmi, 987.0f);
    sm->advanceAndApply(0.0f);

    CHECK(run->text() == "second");
    CHECK(anyNodeHasX(artboard.get(), 987.0f));
}

TEST_CASE("keyframe interpolation reads the data-bound start value",
          "[data binding]")
{
    auto file = ReadRiveFile("assets/data_bind_keyframes_test.riv");
    auto artboard = file->artboardDefault();
    REQUIRE(artboard != nullptr);
    auto sm = artboard->stateMachineAt(0);
    auto vmi = file->createDefaultViewModelInstance(artboard.get());

    // A large, distinctive start value the authored keyframe would never
    // produce. The node tweens from this bound start toward its authored end,
    // so once it's into the tween its x must be strictly between the two,
    // proving the interpolation's from-endpoint is the bound value (not the
    // authored one).
    const float boundStart = 100000.0f;
    setStartX(vmi, boundStart);
    sm->bindViewModelInstance(vmi);

    sm->advanceAndApply(0.0f);
    REQUIRE(anyNodeHasX(artboard.get(), boundStart)); // start endpoint applied

    sm->advanceAndApply(0.5f); // well into the tween
    bool inTween = false;
    for (auto* node : artboard->find<Node>())
    {
        // Moved off the bound start but still dominated by it => interpolating
        // from the bound value.
        if (node->x() > 50000.0f && node->x() < boundStart)
        {
            inTween = true;
            break;
        }
    }
    CHECK(inTween);
}

TEST_CASE("standalone animation instance ignores keyframe value binds",
          "[data binding]")
{
    auto file = ReadRiveFile("assets/data_bind_keyframes_test.riv");
    auto artboard = file->artboardDefault();
    REQUIRE(artboard != nullptr);
    REQUIRE(artboard->animationCount() > 0);

    auto vmi = file->createDefaultViewModelInstance(artboard.get());
    setStartText(vmi, "SHOULD_NOT_BIND");
    setStartX(vmi, 424242.0f);
    // Bind the artboard's data context but drive playback via a *standalone*
    // LinearAnimationInstance (not a state machine). Keyframe value binds are
    // built only for state-machine-driven instances, so the authored keyframe
    // values must apply here instead of the bound ones.
    artboard->bindViewModelInstance(vmi);

    auto animation = artboard->animationAt(0);
    REQUIRE(animation != nullptr);
    animation->advanceAndApply(0.0f);

    auto* run = firstTextRun(artboard.get());
    REQUIRE(run != nullptr);
    CHECK(run->text() != "SHOULD_NOT_BIND");
    CHECK_FALSE(anyNodeHasX(artboard.get(), 424242.0f));
}