tests/gm/strokedlines.cpp

/*
 * Copyright 2016 Google Inc.
 * Copyright 2022 Rive
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include <cassert>

#include "gm.hpp"
#include "gmutils.hpp"
#include "rive/renderer.hpp"
#include "rive/math/mat2d.hpp"
#include "rive/math/math_types.hpp"
#include "rive/math/vec2d.hpp"

using namespace rivegm;
using namespace rive;

constexpr int kNumColumns = 3;
constexpr int kNumPaints = 2;
constexpr int kNumRows = 5;
constexpr int kRadius = 40; // radius of the snowflake
constexpr int kPad = 5;     // padding on both sides of the snowflake
constexpr int kNumSpokes = 6;
constexpr float kStrokeWidth = 5.0f;

static void draw_fins(Renderer* renderer,
                      const Vec2D& offset,
                      float angle,
                      RenderPaint* paint)
{
    float cos, sin;

    // first fin
    sin = sinf(angle + (math::PI / 4));
    cos = cosf(angle + (math::PI / 4));
    sin *= kRadius / 2.0f;
    cos *= kRadius / 2.0f;

    Path p;
    p->moveTo(offset.x, offset.y);
    p->lineTo(offset.x + cos, offset.y + sin);
    renderer->drawPath(p, paint);

    // second fin
    sin = sinf(angle - (math::PI / 4));
    cos = cosf(angle - (math::PI / 4));
    sin *= kRadius / 2.0f;
    cos *= kRadius / 2.0f;

    p = Path();
    p->moveTo(offset.x, offset.y);
    p->lineTo(offset.x + cos, offset.y + sin);
    renderer->drawPath(p, paint);
}

// draw a snowflake centered at the origin
static void draw_snowflake(Renderer* renderer, RenderPaint* paint)
{
    renderer->clipPath(PathBuilder::Rect(
        {-kRadius - kPad, -kRadius - kPad, kRadius + kPad, kRadius + kPad}));

    float sin, cos, angle = 0.0f;
    for (int i = 0; i < kNumSpokes / 2;
         ++i, angle += math::PI / (int)(kNumSpokes / 2))
    {
        sin = sinf(angle);
        cos = cosf(angle);
        sin *= kRadius;
        cos *= kRadius;

        // main spoke
        Path p;
        p->moveTo(-cos, -sin);
        p->lineTo(cos, sin);
        renderer->drawPath(p, paint);

        // fins on positive side
        const Vec2D posOffset = Vec2D(0.5f * cos, 0.5f * sin);
        draw_fins(renderer, posOffset, angle, paint);

        // fins on negative side
        const Vec2D negOffset = Vec2D(-0.5f * cos, -0.5f * sin);
        draw_fins(renderer, negOffset, angle + math::PI, paint);
    }
}

static void draw_row(Renderer* renderer,
                     RenderPaint* paint,
                     const Mat2D& localMatrix)
{
    renderer->translate(kRadius + kPad, 0.0f);

    for (auto cap : {StrokeCap::butt, StrokeCap::round, StrokeCap::square})
    {
        paint->thickness(kStrokeWidth);
        paint->style(RenderPaintStyle::stroke);
        paint->cap(cap);

        renderer->save();
        renderer->transform(localMatrix);
        draw_snowflake(renderer, paint);
        renderer->restore();

        renderer->translate(2 * (kRadius + kPad), 0.0f);
    }
}

namespace skiagm
{

// This GM exercises the special case of a stroked lines.
// Various shaders are applied to ensure the coordinate spaces work out right.
class StrokedLinesGM : public GM
{
public:
    StrokedLinesGM() :
        GM(kNumColumns * (2 * kRadius + 2 * kPad),
           kNumRows * (2 * kRadius + 2 * kPad))
    {}

protected:
    void onOnceBeforeDraw() override
    {
        // paints
        {
            // basic white
            fPaints[0]->color(0xffffffff);
        }
        {
            // gradient
            ColorInt colors[] = {0xffff0000, 0xff00ff00};
            Vec2D pts[] = {{-kRadius - kPad, -kRadius - kPad},
                           {kRadius + kPad, kRadius + kPad}};
            float stops[] = {0, 1};

            auto sh =
                TestingWindow::Get()->factory()->makeLinearGradient(pts[0].x,
                                                                    pts[0].y,
                                                                    pts[1].x,
                                                                    pts[1].y,
                                                                    colors,
                                                                    stops,
                                                                    2);
            fPaints[1]->shader(sh);
        }
        // {
        //     // dashing
        //     float intervals[] = {kStrokeWidth, kStrokeWidth};
        //     int intervalCount = (int)SK_ARRAY_COUNT(intervals);
        //     SkPaint p;
        //     p.setColor(SK_ColorWHITE);
        //     p.setPathEffect(SkDashPathEffect::Make(intervals, intervalCount,
        //     kStrokeWidth));
        //
        //     fPaints.push_back(p);
        // }
        // {
        //     // Bitmap shader
        //     SkBitmap bm;
        //     bm.allocN32Pixels(2, 2);
        //     *bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
        //     *bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = 0x0;
        //
        //     SkMatrix m;
        //     m.setRotate(12.0f);
        //     m.preScale(3.0f, 3.0f);
        //
        //     SkPaint p;
        //     p.setShader(
        //         bm.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat,
        //         SkSamplingOptions(), m));
        //     fPaints.push_back(p);
        // }
        // {
        //     // blur
        //     SkPaint p;
        //     p.setColor(SK_ColorWHITE);
        //     p.setMaskFilter(SkMaskFilter::MakeBlur(kOuter_SkBlurStyle, 3.0f));
        //     fPaints.push_back(p);
        // }

        // matrices
        {
            // rotation
            Mat2D m = Mat2D::fromRotation(12.0f * math::PI / 180);

            fMatrices.push_back(m);
        }
        {
            // skew
            Mat2D m;
            m.xy(0.5f);
            m.yx(0.3f);

            fMatrices.push_back(m);
        }
        {
            // perspective - not supported
            Mat2D m;

            fMatrices.push_back(m);
        }

        assert(kNumRows == kNumPaints + fMatrices.size());
    }

    ColorInt clearColor() const override { return 0xFF1A65D7; }

    void onDraw(rive::Renderer* renderer) override
    {
        renderer->translate(0, kRadius + kPad);

        for (int i = 0; i < kNumPaints; ++i)
        {
            renderer->save();
            draw_row(renderer, fPaints[i], Mat2D());
            renderer->restore();

            renderer->translate(0, 2 * (kRadius + kPad));
        }

        for (size_t i = 0; i < fMatrices.size(); ++i)
        {
            renderer->save();
            draw_row(renderer, fPaints[0], fMatrices[i]);
            renderer->restore();

            renderer->translate(0, 2 * (kRadius + kPad));
        }
    }

private:
    Paint fPaints[kNumPaints];
    std::vector<Mat2D> fMatrices;

    using INHERITED = GM;
};

//////////////////////////////////////////////////////////////////////////////

GMREGISTER(strokedlines, return new StrokedLinesGM;)
} // namespace skiagm