include/rive/animation/layer_state.hpp

#ifndef _RIVE_LAYER_STATE_HPP_
#define _RIVE_LAYER_STATE_HPP_
#include "rive/generated/animation/layer_state_base.hpp"
#include <stdio.h>
#include <vector>

namespace rive
{
class ArtboardInstance;
class StateTransition;
class LayerStateImporter;
class StateMachineLayerImporter;
class StateInstance;

class LayerState : public LayerStateBase
{
  friend class LayerStateImporter;
  friend class StateMachineLayerImporter;

private:
  std::vector<StateTransition*> m_Transitions;
  void addTransition(StateTransition* transition);

public:
  ~LayerState() override;
  StatusCode onAddedDirty(CoreContext* context) override;
  StatusCode onAddedClean(CoreContext* context) override;

  StatusCode import(ImportStack& importStack) override;

  size_t transitionCount() const
  {
#ifdef WITH_RIVE_EDITOR
    if (m_Transitions.empty())
    {
      return m_editorTransitions.size();
    }
#endif
    return m_Transitions.size();
  }
  StateTransition* transition(size_t index) const
  {
    if (index < m_Transitions.size())
    {
      return m_Transitions[index];
    }
#ifdef WITH_RIVE_EDITOR
    if (m_Transitions.empty() && index < m_editorTransitions.size())
    {
      return m_editorTransitions[index];
    }
#endif
    return nullptr;
  }

  /// Make an instance of this state that can be advanced and applied by
  /// the state machine when it is active or being transitioned from.
  virtual std::unique_ptr<StateInstance> makeInstance(
      ArtboardInstance* instance) const;

  /// Whether every condition on this state's transitions only reads values
  /// whose changes reach the state machine instance (view model values it
  /// binds, and its data context). A layer whose search found nothing from
  /// such a state can skip searching again until one of them changes. Set
  /// once by StateMachine::onAddedClean; never set in editor builds, whose
  /// transitions change after import.
  bool transitionsSettleSafe() const { return m_transitionsSettleSafe; }
  void transitionsSettleSafe(bool value) { m_transitionsSettleSafe = value; }

  /// Whether none of this state's transitions waits on an exit time, the only
  /// thing that reads how long the state has been active. A settled layer in
  /// such a state that keys nothing can skip advancing it. Set with
  /// transitionsSettleSafe.
  bool transitionsIgnoreTime() const { return m_transitionsIgnoreTime; }
  void transitionsIgnoreTime(bool value) { m_transitionsIgnoreTime = value; }

#ifdef WITH_RIVE_EDITOR
  // Editor-only parallel non-owning transition list. `m_Transitions`
  // is owned by `LayerState::~LayerState`. See
  // `StateMachineLayer::m_editorStates` for the pattern rationale.
  void addTransitionForEditor(StateTransition* transition);
  void clearEditorTransitions();
  size_t editorTransitionCount() const { return m_editorTransitions.size(); }
#endif

private:
#ifdef WITH_RIVE_EDITOR
  std::vector<StateTransition*> m_editorTransitions;
#endif
  bool m_transitionsSettleSafe = false;
  bool m_transitionsIgnoreTime = false;
};
} // namespace rive

#endif