include/rive/property_recorder.hpp

#ifndef _RIVE_PROPERTY_RECORDER_HPP_
#define _RIVE_PROPERTY_RECORDER_HPP_

#include "rive/core/binary_writer.hpp"
#include "rive/core/vector_binary_writer.hpp"
#include "rive/core/binary_data_reader.hpp"
#include "rive/core/binary_data_reader.hpp"
#include <algorithm>
#include <memory>
#include <string>
#include <vector>

namespace rive
{
class Artboard;
class StateMachine;
class StateMachineLayer;
class StateMachineInput;
class LayerState;
class LinearAnimation;
class KeyedObject;
class Core;
class StateMachineInstance;
class CoreObjectData
{
private:
  std::vector<uint16_t> m_propertyKeys;

public:
  CoreObjectData(uint32_t id) { objectId = id; }
  uint32_t objectId;
  void addPropertyKey(uint16_t key)
  {
    auto it = std::find(m_propertyKeys.begin(), m_propertyKeys.end(), key);
    if (it == m_propertyKeys.end())
    {
      m_propertyKeys.push_back(key);
    }
  }
  std::vector<uint16_t>* propertyKeys() { return &m_propertyKeys; }
};

class PropertyRecorder
{
private:
  VectorBinaryWriter m_binaryWriter;
  BinaryDataReader m_binaryReader;
  std::vector<uint8_t> m_WriteBuffer;
  VectorBinaryWriter m_binaryWriterSM;
  BinaryDataReader m_binaryReaderSM;
  std::vector<uint8_t> m_WriteBufferSM;
  std::vector<std::unique_ptr<CoreObjectData>> m_coreObjectsData;
  void recordDataBinds(const Artboard* artboard);
  void recordStateMachine(const StateMachine* stateMachine);
  void recordStateMachineInput(const StateMachineInput* stateMachineInput);
  void recordStateMachineLayer(const StateMachineLayer* stateMachineLayer);
  void recordStateMachineLayerState(const LayerState* layerState);
  void recordLinearAnimation(const LinearAnimation* linearAnimation);
  void recordKeyedObject(const KeyedObject* keyedObject);
  CoreObjectData* getCoreObjectData(uint32_t id);
  void writeProperties(const Artboard* artboard);
  void addPropertyKey(CoreObjectData* coreObjectData, int propertyKey);
  int getObjectId(const Artboard* artboard, Core* object);
  void writeObjectId(uint32_t objectId, VectorBinaryWriter& writer);
  void writeTotalProperties(uint32_t value, VectorBinaryWriter& writer);
  void writePropertyKey(uint32_t value, VectorBinaryWriter& writer);
  void writePropertyValue(float value, VectorBinaryWriter& writer);
  void writePropertyValue(int value, VectorBinaryWriter& writer);
  void writePropertyValue(uint32_t value, VectorBinaryWriter& writer);
  void writePropertyValue(std::string value, VectorBinaryWriter& writer);
  void writePropertyValue(bool value, VectorBinaryWriter& writer);
  void writeSeparator();
  void complete(
      VectorBinaryWriter& writer,
      BinaryDataReader& reader,
      std::vector<uint8_t>& buffer);

public:
  PropertyRecorder();
  void recordArtboard(const Artboard* artboard);
  void recordStateMachineInputs(const StateMachine* stateMachine);
  void apply(Artboard* artboard);
  void apply(StateMachineInstance* stateMachineInstace);
  void clear();
};
} // namespace rive
#endif