tests/gm/cubicpaths.cpp

/*
 * Copyright 2011 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 "gm.hpp"
#include "gmutils.hpp"
#include "rive/shapes/paint/color.hpp"
#include "rive/math/mat2d.hpp"
#include "rive/renderer.hpp"

using namespace rivegm;
using namespace rive;

// https://bug.skia.org/1316 shows that this cubic, when slightly clipped,
// creates big (incorrect) changes to its control points.
class ClippedCubicGM : public GM
{
public:
    ClippedCubicGM() : GM(600, 500) {}

private:
    void onDraw(Renderer* canvas) override
    {
        canvas->translate(25, 25);
        Path path;
        path->moveTo(0, 0);
        path->cubicTo(140, 150, 40, 10, 170, 150);

        Paint paint;
        AABB bounds = {0, 0, 170, 150}; // path.getBounds();

        for (float dy = -1; dy <= 1; dy += 1)
        {
            canvas->save();
            for (float dx = -1; dx <= 1; dx += 1)
            {
                canvas->save();
                canvas->clipPath(PathBuilder::Rect(bounds));
                canvas->translate(dx, dy);
                canvas->drawPath(path, paint);
                canvas->restore();

                canvas->translate(bounds.width(), 0);
            }
            canvas->restore();
            canvas->translate(0, bounds.height());
        }
    }
};

class ClippedCubic2GM : public GM
{
public:
    ClippedCubic2GM() : GM(725, 325) {}

private:
    void onDraw(Renderer* canvas) override
    {
        canvas->translate(25, 25);
        canvas->save();
        canvas->translate(-2, 120);
        drawOne(canvas, fPath, {0, 0, 80, 150});
        canvas->translate(170, 0);
        drawOne(canvas, fPath, {0, 0, 80, 100});
        canvas->translate(170, 0);
        drawOne(canvas, fPath, {0, 0, 30, 150});
        canvas->translate(170, 0);
        drawOne(canvas, fPath, {0, 0, 10, 150});
        canvas->restore();
        canvas->save();
        canvas->translate(20, -2);
        drawOne(canvas, fFlipped, {0, 0, 150, 80});
        canvas->translate(170, 0);
        drawOne(canvas, fFlipped, {0, 0, 100, 80});
        canvas->translate(170, 0);
        drawOne(canvas, fFlipped, {0, 0, 150, 30});
        canvas->translate(170, 0);
        drawOne(canvas, fFlipped, {0, 0, 150, 10});
        canvas->restore();
    }

    void drawOne(Renderer* canvas, const Path& path, const AABB& clip)
    {
        Paint framePaint, fillPaint;
        framePaint->style(RenderPaintStyle::stroke);
        canvas->drawPath(PathBuilder::Rect(clip), framePaint);
        canvas->drawPath(path, framePaint);
        canvas->save();
        canvas->clipPath(PathBuilder::Rect(clip));
        canvas->drawPath(path, fillPaint);
        canvas->restore();
    }

    void onOnceBeforeDraw() override
    {
        fPath->moveTo(69.7030518991886f, 0);
        fPath->cubicTo(69.7030518991886f,
                       21.831149999999997f,
                       58.08369508178456f,
                       43.66448333333333f,
                       34.8449814469765f,
                       65.5f);
        fPath->cubicTo(11.608591683531916f,
                       87.33115f,
                       -0.010765133872116195f,
                       109.16448333333332f,
                       -0.013089005235602302f,
                       131);
        fPath->close();
        Mat2D matrix;
        matrix[0] = 0.0f;
        matrix[1] = 1.0f;
        matrix[2] = 1.0f;
        matrix[3] = 0.0f;
        fFlipped->addRenderPath(fPath, matrix);
    }

    Path fPath;
    Path fFlipped;
};

class CubicPathGM : public GM
{
public:
    CubicPathGM() : GM(825, 175) {}

private:
    void drawPath(Path& path,
                  Renderer* canvas,
                  ColorInt color,
                  const AABB& clip,
                  StrokeCap cap,
                  StrokeJoin join,
                  RenderPaintStyle style,
                  FillRule fill,
                  float strokeWidth)
    {
        path->fillRule(fill);
        Paint paint;
        paint->cap(cap);
        paint->thickness(strokeWidth);
        paint->join(join);
        paint->color(color);
        paint->style(style);
        canvas->save();
        canvas->clipPath(PathBuilder::Rect(clip));
        canvas->drawPath(path, paint);
        canvas->restore();
    }

    void onDraw(Renderer* canvas) override
    {
        struct FillAndName
        {
            FillRule fFill;
            const char* fName;
        };
        constexpr FillAndName gFills[] = {
            {FillRule::nonZero, "Winding"},
            {FillRule::evenOdd, "Even / Odd"},
        };
        struct StyleAndName
        {
            RenderPaintStyle fStyle;
            const char* fName;
        };
        constexpr StyleAndName gStyles[] = {
            {RenderPaintStyle::fill, "Fill"},
            {RenderPaintStyle::stroke, "Stroke"},
        };
        struct CapAndName
        {
            StrokeCap fCap;
            StrokeJoin fJoin;
            const char* fName;
        };
        constexpr CapAndName gCaps[] = {
            {StrokeCap::butt, StrokeJoin::bevel, "Butt"},
            {StrokeCap::round, StrokeJoin::round, "Round"},
            {StrokeCap::square, StrokeJoin::bevel, "Square"}};
        struct PathAndName
        {
            Path fPath;
            const char* fName;
        };
        PathAndName path;
        path.fPath->moveTo(25 * 1.0f, 10 * 1.0f);
        path.fPath->cubicTo(40 * 1.0f,
                            20 * 1.0f,
                            60 * 1.0f,
                            20 * 1.0f,
                            75 * 1.0f,
                            10 * 1.0f);
        path.fName = "moveTo-cubic";

        AABB rect = {0, 0, 100 * 1.0f, 30 * 1.0f};
        canvas->save();
        canvas->translate(10 * 1.0f, 30 * 1.0f);
        canvas->save();
        for (size_t cap = 0; cap < std::size(gCaps); ++cap)
        {
            if (0 < cap)
            {
                canvas->translate((rect.width() + 40 * 1.0f) *
                                      std::size(gStyles),
                                  0);
            }
            canvas->save();
            for (size_t fill = 0; fill < std::size(gFills); ++fill)
            {
                if (0 < fill)
                {
                    canvas->translate(0, rect.height() + 40 * 1.0f);
                }
                canvas->save();
                for (size_t style = 0; style < std::size(gStyles); ++style)
                {
                    if (0 < style)
                    {
                        canvas->translate(rect.width() + 40 * 1.0f, 0);
                    }

                    ColorInt color = 0xff007000;
                    this->drawPath(path.fPath,
                                   canvas,
                                   color,
                                   rect,
                                   gCaps[cap].fCap,
                                   gCaps[cap].fJoin,
                                   gStyles[style].fStyle,
                                   gFills[fill].fFill,
                                   1.0f * 10);

                    Paint rectPaint;
                    rectPaint->color(0xFF000000);
                    rectPaint->style(RenderPaintStyle::stroke);
                    rectPaint->thickness(-1);
                    canvas->drawPath(PathBuilder::Rect(rect), rectPaint);
                }
                canvas->restore();
            }
            canvas->restore();
        }
        canvas->restore();
        canvas->restore();
    }
};

class CubicClosePathGM : public GM
{
public:
    CubicClosePathGM() : GM(825, 175) {}

private:
    void drawPath(Path& path,
                  Renderer* canvas,
                  ColorInt color,
                  const AABB& clip,
                  StrokeCap cap,
                  StrokeJoin join,
                  RenderPaintStyle style,
                  FillRule fill,
                  float strokeWidth)
    {
        path->fillRule(fill);
        Paint paint;
        paint->cap(cap);
        paint->thickness(strokeWidth);
        paint->join(join);
        paint->color(color);
        paint->style(style);
        canvas->save();
        canvas->clipPath(PathBuilder::Rect(clip));
        canvas->drawPath(path, paint);
        canvas->restore();
    }

    void onDraw(Renderer* canvas) override
    {
        struct FillAndName
        {
            FillRule fFill;
            const char* fName;
        };
        constexpr FillAndName gFills[] = {
            {FillRule::nonZero, "Winding"},
            {FillRule::evenOdd, "Even / Odd"},
        };
        struct StyleAndName
        {
            RenderPaintStyle fStyle;
            const char* fName;
        };
        constexpr StyleAndName gStyles[] = {
            {RenderPaintStyle::fill, "Fill"},
            {RenderPaintStyle::stroke, "Stroke"},
        };
        struct CapAndName
        {
            StrokeCap fCap;
            StrokeJoin fJoin;
            const char* fName;
        };
        constexpr CapAndName gCaps[] = {
            {StrokeCap::butt, StrokeJoin::bevel, "Butt"},
            {StrokeCap::round, StrokeJoin::round, "Round"},
            {StrokeCap::square, StrokeJoin::bevel, "Square"}};
        struct PathAndName
        {
            Path fPath;
            const char* fName;
        };
        PathAndName path;
        path.fPath->moveTo(25 * 1.0f, 10 * 1.0f);
        path.fPath->cubicTo(40 * 1.0f,
                            20 * 1.0f,
                            60 * 1.0f,
                            20 * 1.0f,
                            75 * 1.0f,
                            10 * 1.0f);
        path.fPath->close();
        path.fName = "moveTo-cubic-close";

        AABB rect = {0, 0, 100 * 1.0f, 30 * 1.0f};
        canvas->save();
        canvas->translate(10 * 1.0f, 30 * 1.0f);
        canvas->save();
        for (size_t cap = 0; cap < std::size(gCaps); ++cap)
        {
            if (0 < cap)
            {
                canvas->translate((rect.width() + 40 * 1.0f) *
                                      std::size(gStyles),
                                  0);
            }
            canvas->save();
            for (size_t fill = 0; fill < std::size(gFills); ++fill)
            {
                if (0 < fill)
                {
                    canvas->translate(0, rect.height() + 40 * 1.0f);
                }
                canvas->save();
                for (size_t style = 0; style < std::size(gStyles); ++style)
                {
                    if (0 < style)
                    {
                        canvas->translate(rect.width() + 40 * 1.0f, 0);
                    }

                    ColorInt color = 0xff007000;
                    this->drawPath(path.fPath,
                                   canvas,
                                   color,
                                   rect,
                                   gCaps[cap].fCap,
                                   gCaps[cap].fJoin,
                                   gStyles[style].fStyle,
                                   gFills[fill].fFill,
                                   1.0f * 10);

                    Paint rectPaint;
                    rectPaint->color(0xFF000000);
                    rectPaint->style(RenderPaintStyle::stroke);
                    rectPaint->thickness(-1);
                    canvas->drawPath(PathBuilder::Rect(rect), rectPaint);
                }
                canvas->restore();
            }
            canvas->restore();
        }
        canvas->restore();
        canvas->restore();
    }
};

DEF_SIMPLE_GM(bug5099, 50, 50, canvas)
{
    Paint p;
    p->color(0xFFFF0000);
    p->style(RenderPaintStyle::stroke);
    p->thickness(10);

    Path path;
    path->moveTo(6, 27);
    path->cubicTo(31.5f, 1.5f, 3.5f, 4.5f, 29, 29);
    canvas->drawPath(path, p);
}

DEF_SIMPLE_GM(bug6083, 100, 50, canvas)
{
    Paint p;
    p->color(0xFFFF0000);
    p->style(RenderPaintStyle::stroke);
    p->thickness(15);
    canvas->translate(-500, -130);
    Path path;
    path->moveTo(500.988f, 155.200f);
    path->lineTo(526.109f, 155.200f);
    Vec2D p1 = {526.109f, 155.200f};
    Vec2D p2 = {525.968f, 212.968f};
    Vec2D p3 = {526.109f, 241.840f};
    path->cubicTo(p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);
    canvas->drawPath(path, p);
    canvas->translate(50, 0);
    path = Path();
    p2 = Vec2D(525.968f, 213.172f);
    path->moveTo(500.988f, 155.200f);
    path->lineTo(526.109f, 155.200f);
    path->cubicTo(p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);
    canvas->drawPath(path, p);
}

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

GMREGISTER(cubicpath, return new CubicPathGM;)
GMREGISTER(cubicclosepath, return new CubicClosePathGM;)
GMREGISTER(clippedcubic, return new ClippedCubicGM;)
GMREGISTER(clippedcubic2, return new ClippedCubic2GM;)