tests/include/riv_bytes.hpp

#ifndef _RIVE_TESTS_RIV_BYTES_HPP_
#define _RIVE_TESTS_RIV_BYTES_HPP_

#include "rive/core/vector_binary_writer.hpp"
#include "rive/file.hpp"
#include "rive/generated/artboard_base.hpp"
#include "rive/generated/backboard_base.hpp"
#include "rive/generated/component_base.hpp"
#include "rive/generated/layout_component_base.hpp"

#include <map>
#include <string>
#include <vector>

// A minimal .riv assembled by hand, so an object or a property can be placed
// where no exporter would put it -- which is how the import paths that only
// a malformed or forward-dated file reaches get exercised.
class RivBytes
{
public:
  RivBytes() : m_writer(&m_objects) {}

  void object(uint16_t typeKey) { m_writer.writeVarUint((uint64_t)typeKey); }
  void end() { m_writer.writeVarUint((uint64_t)0); }

  // ToC field ids: 0 uint (bools ride as uints), 1 string, 2 double.
  void propUint(uint16_t key, uint64_t value)
  {
    m_toc[key] = 0;
    m_writer.writeVarUint((uint64_t)key);
    m_writer.writeVarUint(value);
  }
  void propBool(uint16_t key, bool value)
  {
    m_toc[key] = 0;
    m_writer.writeVarUint((uint64_t)key);
    m_writer.write((uint8_t)(value ? 1 : 0));
  }
  void propString(uint16_t key, const std::string& value)
  {
    m_toc[key] = 1;
    m_writer.writeVarUint((uint64_t)key);
    m_writer.write(value);
  }
  void propFloat(uint16_t key, float value)
  {
    m_toc[key] = 2;
    m_writer.writeVarUint((uint64_t)key);
    m_writer.write(value);
  }
  // A key the file's ToC does not describe.
  void propUintOutsideToc(uint16_t key, uint64_t value)
  {
    m_writer.writeVarUint((uint64_t)key);
    m_writer.writeVarUint(value);
  }

  std::vector<uint8_t> bytes() const
  {
    std::vector<uint8_t> out;
    rive::VectorBinaryWriter writer(&out);
    writer.write((const uint8_t*)"RIVE", 4);
    writer.writeVarUint((uint64_t)rive::File::majorVersion);
    writer.writeVarUint((uint64_t)rive::File::minorVersion);
    writer.writeVarUint((uint64_t)0); // file id
    for (const auto& entry : m_toc)
    {
      writer.writeVarUint((uint64_t)entry.first);
    }
    writer.writeVarUint((uint64_t)0);
    // The reader refreshes its packed int every 8 bits: one uint32 per
    // four keys (RuntimeHeader::read).
    uint32_t packed = 0;
    int bit = 0;
    for (const auto& entry : m_toc)
    {
      packed |= entry.second << bit;
      bit += 2;
      if (bit == 8)
      {
        writer.write(packed);
        packed = 0;
        bit = 0;
      }
    }
    if (bit != 0)
    {
      writer.write(packed);
    }
    out.insert(out.end(), m_objects.begin(), m_objects.end());
    return out;
  }

private:
  std::vector<uint8_t> m_objects;
  rive::VectorBinaryWriter m_writer;
  std::map<uint16_t, uint32_t> m_toc;
};

// One 100x100 artboard named "A", with no Backboard of its own -- for streams
// that need to place something between the two.
inline void writeArtboardObject(RivBytes& riv)
{
  riv.object(rive::ArtboardBase::typeKey);
  riv.propString(rive::ComponentBase::namePropertyKey, "A");
  riv.propFloat(rive::LayoutComponentBase::widthPropertyKey, 100.0f);
  riv.propFloat(rive::LayoutComponentBase::heightPropertyKey, 100.0f);
  riv.end();
}

// The smallest loadable file: a Backboard and one 100x100 artboard named "A".
inline void writeArtboard(RivBytes& riv)
{
  riv.object(rive::BackboardBase::typeKey);
  riv.end();
  writeArtboardObject(riv);
}

#endif