tests/gm/image_paint.cpp

/*
 * Copyright 2022 Rive
 */

#include "gm.hpp"
#include "gmutils.hpp"
#include "rive/math/math_types.hpp"

#include "assets/batdude.png.hpp"
#include "assets/nomoon.png.hpp"

using namespace rivegm;

class ImagePaintGM : public GM
{
public:
  ImagePaintGM() : GM(512, 512) {}

  void onDraw(rive::Renderer* ren) override
  {
    rive::Span<uint8_t> images[] = {
        assets::batdude_png(),
        assets::nomoon_png(),
    };

    rive::AABB r = {0, 0, 250, 250};

    {
      Paint p;
      p->color(0xFF2f2f2f);
      draw_rect(ren, {0, 0, 512, 512}, p);
    }

    rive::Factory* factory = TestingWindow::Get()->factory();

    ren->save();
    ren->translate(256, 256);

    auto img0 = LoadImage(images[0]);
    auto img1 = LoadImage(images[1]);
    if (img0 == nullptr || img1 == nullptr)
    {
      ren->restore();
      Paint p;
      p->color(0xFFFF0000);
      draw_rect(ren, {0, 0, 530, 310}, p);
      return;
    }

    {
      Paint p;
      p->color(0xFFB299FF);
      rive::ColorInt gradientColors[] = {
          0xFFFF9B9Bu,
          0xFFC5FF8Cu,
          0xFF70A6FFu,
      };

      float gradientStops[] = {0.0f, 0.5f, 1.0f};
      static_assert(std::size(gradientColors) == std::size(gradientStops));
      p->modulatedImage(
          img0.get(),
          {
              .wrapX = rive::ImageWrap::mirror,
              .wrapY = rive::ImageWrap::repeat,
              .filter = rive::ImageFilter::bilinear,
          },
          rive::Mat2D::fromScale(128.0f, 128.0f) *
              rive::Mat2D::fromTranslate(0.5f, 0.5f) *
              rive::Mat2D::fromRotation(45.0f * rive::math::PI / 180.0f));

      p->shader(factory->makeLinearGradient(
          0.0f,
          -100.0f,
          0.0f,
          100.0f,
          gradientColors,
          gradientStops,
          std::size(gradientColors)));

      draw_oval(ren, {-220.0f, -220.0f, 220.0f, 220.0f}, p);

      p->modulatedImage(
          img1.get(),
          {
              .wrapX = rive::ImageWrap::repeat,
              .wrapY = rive::ImageWrap::mirror,
              .filter = rive::ImageFilter::bilinear,
          },
          rive::Mat2D::fromScale(128.0f, 128.0f));
      p->color(0xFFFFA5F3);
      p->style(rive::RenderPaintStyle::stroke);
      p->thickness(30.0f);
      p->feather(30.0f);
      draw_oval(ren, {-220.0f, -220.0f, 220.0f, 220.0f}, p);
    }
    ren->restore();
  }
};
GMREGISTER(image_paint, return new ImagePaintGM)