include/rive/animation/state_transition.hpp

#ifndef _RIVE_STATE_TRANSITION_HPP_
#define _RIVE_STATE_TRANSITION_HPP_
#include "rive/animation/keyframe_interpolator.hpp"
#include "rive/animation/state_transition_flags.hpp"
#include "rive/generated/animation/state_transition_base.hpp"
#ifdef WITH_RIVE_EDITOR
#include "rive/editor/object_arena.hpp"
#endif
#include <stdio.h>
#include <vector>

namespace rive
{
class LayerState;
class StateMachineLayerImporter;
class StateTransitionImporter;
class TransitionCondition;
class StateInstance;
class StateMachineInstance;
class StateMachineLayerInstance;
class LinearAnimation;
class LinearAnimationInstance;

enum class AllowTransition : unsigned char
{
    no,
    waitingForExit,
    yes
};

class StateTransition : public StateTransitionBase
{
    friend class StateMachineLayerImporter;
    friend class StateTransitionImporter;

private:
    StateTransitionFlags transitionFlags() const
    {
        return static_cast<StateTransitionFlags>(flags());
    }
    LayerState* m_StateTo = nullptr;
    uint32_t m_EvaluatedRandomWeight = 1;
    KeyFrameInterpolator* m_Interpolator = nullptr;
#ifdef WITH_RIVE_EDITOR
    // Slice 6 Phase E dual-storage. See targeted_constraint.hpp.
    CoreHandle m_StateToHandle;
    CoreHandle m_InterpolatorHandle;
#endif

    std::vector<TransitionCondition*> m_Conditions;
    void addCondition(TransitionCondition* condition);

public:
    ~StateTransition() override;
#ifdef WITH_RIVE_EDITOR
    // Bodies in editor_native/native/src/editor/animation/sm/
    // state_transition_editor.cpp.
    const LayerState* stateTo() const;
    KeyFrameInterpolator* interpolator() const;
#else
    inline const LayerState* stateTo() const { return m_StateTo; }
    inline KeyFrameInterpolator* interpolator() const { return m_Interpolator; }
#endif

    inline uint32_t evaluatedRandomWeight() const
    {
        return m_EvaluatedRandomWeight;
    }
    void evaluatedRandomWeight(uint32_t value)
    {
        m_EvaluatedRandomWeight = value;
    }

    StatusCode onAddedDirty(CoreContext* context) override;
    StatusCode onAddedClean(CoreContext* context) override;

    /// Whether the transition is marked disabled (usually done in the
    /// editor).
    bool isDisabled() const
    {
        return (transitionFlags() & StateTransitionFlags::Disabled) ==
               StateTransitionFlags::Disabled;
    }

    /// Returns AllowTransition::yes when this transition can be taken from
    /// stateFrom with the given inputs.
    AllowTransition allowed(StateInstance* stateFrom,
                            StateMachineInstance* stateMachineInstance,
                            StateMachineLayerInstance* layerInstance) const;

    /// Whether the animation is held at exit or if it keeps advancing
    /// during mixing.
    bool pauseOnExit() const
    {
        return (transitionFlags() & StateTransitionFlags::PauseOnExit) ==
               StateTransitionFlags::PauseOnExit;
    }

    /// Whether exit time is enabled. All other conditions still apply, the
    /// exit time is effectively an AND with the rest of the conditions.
    bool enableExitTime() const
    {
        return (transitionFlags() & StateTransitionFlags::EnableExitTime) ==
               StateTransitionFlags::EnableExitTime;
    }

    /// Whether the transition can be interrupted.
    bool enableEarlyExit() const
    {
        return (transitionFlags() & StateTransitionFlags::EnableEarlyExit) ==
               StateTransitionFlags::EnableEarlyExit;
    }

    bool durationIsPercentage() const
    {
        return (transitionFlags() &
                StateTransitionFlags::DurationIsPercentage) ==
               StateTransitionFlags::DurationIsPercentage;
    }

    StatusCode import(ImportStack& importStack) override;

    size_t conditionCount() const
    {
#ifdef WITH_RIVE_EDITOR
        if (m_Conditions.empty())
        {
            return m_editorConditions.size();
        }
#endif
        return m_Conditions.size();
    }
    TransitionCondition* condition(size_t index) const
    {
        if (index < m_Conditions.size())
        {
            return m_Conditions[index];
        }
#ifdef WITH_RIVE_EDITOR
        if (m_Conditions.empty() && index < m_editorConditions.size())
        {
            return m_editorConditions[index];
        }
#endif
        return nullptr;
    }

#ifdef WITH_RIVE_EDITOR
    // Editor-only parallel non-owning condition list (see
    // `StateMachineLayer::m_editorStates` for pattern rationale).
    // The runtime importer's resolve step (`StateMachineLayerImporter::
    // resolve`) sets `m_StateTo` from the layer-relative `stateToId`
    // index and `m_Interpolator` from `interpolatorId`. Coop bypasses
    // that path; finalizeBatch resolves both via `EditorFile::resolve`
    // (CoopId map) and pokes the values in directly.
    void addConditionForEditor(TransitionCondition* condition);
    void clearEditorConditions();
    size_t editorConditionCount() const { return m_editorConditions.size(); }
    // Bodies in state_transition_editor.cpp — dispatch through
    // editorArena() so editor-flow Cores get the handle path while
    // the runtime importer (which still assigns m_StateTo directly
    // via friend class access) keeps the raw fallback.
    void setStateToForEditor(LayerState* state);
    void setInterpolatorForEditor(KeyFrameInterpolator* interp);
#endif

private:
#ifdef WITH_RIVE_EDITOR
    std::vector<TransitionCondition*> m_editorConditions;
#endif

public:
    /// The amount of time to mix the outgoing animation onto the incoming
    /// one when changing state. Only applies when going out from an
    /// AnimationState.
    float mixTime(const LayerState* stateFrom) const;

    /// Computes the exit time in seconds of the stateFrom. Set absolute to
    /// true if you want the returned time to be relative to the entire
    /// animation. Set absolute to false if you want it relative to the work
    /// area.
    float exitTimeSeconds(const LayerState* stateFrom,
                          bool absolute = false) const;

    /// Provide the animation instance to use for computing percentage
    /// durations for exit time.
    virtual const LinearAnimationInstance* exitTimeAnimationInstance(
        const StateInstance* from) const;

    /// Provide the animation to use for computing percentage durations for
    /// exit time.
    virtual const LinearAnimation* exitTimeAnimation(
        const LayerState* from) const;

    /// Retruns true when we need to hold the exit time, also applies the
    /// correct time to the animation instance in the stateFrom, when
    /// applicable (when it's an AnimationState).
    bool applyExitCondition(StateInstance* stateFrom) const;

    /// Marks any trigger based condition as used for this layer
    void useLayerInConditions(StateMachineInstance* stateMachineInstance,
                              StateMachineLayerInstance* layerInstance) const;
};
} // namespace rive

#endif