tests/bench/build_raw_path.cpp

/*
 * Copyright 2022 Rive
 */

#include "bench.hpp"

#include "rive/math/raw_path.hpp"

using namespace rive;

static Vec2D randpt()
{
  return Vec2D(float(rand()), float(rand())) * 100 / (float)RAND_MAX;
}

// Measure the speed of building a RawPath, without growing arrays or figuring
// out the actual path contents.
class BuildRawPath : public Bench
{
public:
  BuildRawPath()
  {
    // Decide the path data we will build with upfront.
    srand(0);
    for (int i = 0; i < 100000; ++i)
    {
      switch (rand() % 4)
      {
        case 0:
          m_verbs.push_back(PathVerb::move);
          m_pts.push_back(randpt());
          break;
        case 1:
          m_verbs.push_back(PathVerb::line);
          for (int i = 0; i < 10; ++i)
          { // 10 lines.
            m_pts.push_back(randpt());
          }
          break;
        case 2:
          m_verbs.push_back(PathVerb::cubic);
          for (int i = 0; i < 10 * 3; ++i)
          { // 10 cubics.
            m_pts.push_back(randpt());
          }
          break;
        case 3:
          m_verbs.push_back(PathVerb::close);
          break;
      }
    }
    run(); // Run once to preallocate the RawPath arrays.
  }

private:
  int run() const override
  {
    const Vec2D* p = m_pts.data();
    m_path.rewind();
    for (PathVerb verb : m_verbs)
    {
      switch (verb)
      {
        case PathVerb::move:
          m_path.move(*p++);
          break;
        case PathVerb::line: // 10 lines.
          for (int i = 0; i < 10; ++i)
          {
            m_path.line(*p++);
          }
          break;
        case PathVerb::cubic: // 10 cubics.
          for (int i = 0; i < 10; ++i)
          {
            m_path.cubic(p[0], p[1], p[2]);
            p += 3;
          }
          break;
        case PathVerb::close:
          m_path.close();
          break;
        case PathVerb::quad:
          RIVE_UNREACHABLE();
      }
    }
    return static_cast<int>(m_path.points().count());
  }

  // Decide verbs and points upfront so we just measure path building time.
  std::vector<PathVerb> m_verbs;
  std::vector<Vec2D> m_pts;

  mutable RawPath m_path;
};

REGISTER_BENCH(BuildRawPath);