| /* |
| * Copyright 2018 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/math/bezier_utils.hpp" |
| #include "rive/renderer.hpp" |
| #include "common/rand.hpp" |
| |
| using namespace rivegm; |
| using namespace rive; |
| |
| static constexpr float kStrokeWidth = 30; |
| static constexpr int kCellSize = 200; |
| static constexpr int kNumCols = 5; |
| static constexpr int kNumRows = 5; |
| static constexpr int kTestWidth = kNumCols * kCellSize; |
| static constexpr int kTestHeight = kNumRows * kCellSize; |
| |
| enum class CellFillMode |
| { |
| kStretch, |
| kCenter |
| }; |
| |
| struct TrickyCubic |
| { |
| Vec2D fPoints[4]; |
| int fNumPts; |
| CellFillMode fFillMode; |
| float fScale = 1; |
| }; |
| |
| // This is a compilation of cubics that have given strokers grief. Feel free to |
| // add more. |
| static const TrickyCubic kTrickyCubics[] = { |
| {{{122, 737}, {348, 553}, {403, 761}, {400, 760}}, |
| 4, |
| CellFillMode::kStretch}, |
| {{{244, 520}, {244, 518}, {1141, 634}, {394, 688}}, |
| 4, |
| CellFillMode::kStretch}, |
| {{{550, 194}, {138, 130}, {1035, 246}, {288, 300}}, |
| 4, |
| CellFillMode::kStretch}, |
| {{{226, 733}, {556, 779}, {-43, 471}, {348, 683}}, |
| 4, |
| CellFillMode::kStretch}, |
| {{{268, 204}, {492, 304}, {352, 23}, {433, 412}}, |
| 4, |
| CellFillMode::kStretch}, |
| {{{172, 480}, {396, 580}, {256, 299}, {338, 677}}, |
| 4, |
| CellFillMode::kStretch}, |
| {{{731, 340}, {318, 252}, {1026, -64}, {367, 265}}, |
| 4, |
| CellFillMode::kStretch}, |
| {{{475, 708}, {62, 620}, {770, 304}, {220, 659}}, |
| 4, |
| CellFillMode::kStretch}, |
| {{{0, 0}, {128, 128}, {128, 0}, {0, 128}}, |
| 4, |
| CellFillMode::kCenter}, // Perfect cusp |
| {{{0, .01f}, {128, 127.999f}, {128, .01f}, {0, 127.99f}}, |
| 4, |
| CellFillMode::kCenter}, // Near-cusp |
| {{{0, -.01f}, {128, 128.001f}, {128, -.01f}, {0, 128.001f}}, |
| 4, |
| CellFillMode::kCenter}, // Near-cusp |
| {{{0, 0}, {0, -10}, {0, -10}, {0, 10}}, |
| 4, |
| CellFillMode::kCenter, |
| 1.098283f}, // Flat line with 180 |
| {{{10, 0}, {0, 0}, {20, 0}, {10, 0}}, |
| 4, |
| CellFillMode::kStretch}, // Flat line with 2 180s |
| {{{39, -39}, {40, -40}, {40, -40}, {0, 0}}, |
| 4, |
| CellFillMode::kStretch}, // Flat diagonal with 180 |
| {{{40, 40}, {0, 0}, {200, 200}, {0, 0}}, |
| 4, |
| CellFillMode::kStretch}, // Diag w/ an internal 180 |
| {{{0, 0}, {1e-2f, 0}, {-1e-2f, 0}, {0, 0}}, |
| 4, |
| CellFillMode::kCenter}, // Circle |
| {{{400.75f, 100.05f}, |
| {400.75f, 100.05f}, |
| {100.05f, 300.95f}, |
| {100.05f, 300.95f}}, |
| 4, |
| CellFillMode::kStretch}, // Flat line with no turns |
| {{{0.5f, 0}, {0, 0}, {20, 0}, {10, 0}}, |
| 4, |
| CellFillMode::kStretch}, // Flat line with 2 180s |
| {{{10, 0}, {0, 0}, {10, 0}, {10, 0}}, |
| 4, |
| CellFillMode::kStretch}, // Flat line with a 180 |
| {{{1, 1}, {2, 1}, {1, 1}, {1, std::numeric_limits<float>::quiet_NaN()}}, |
| 3, |
| CellFillMode::kStretch}, // Flat QUAD with a cusp |
| {{{1, 1}, |
| {100, 1}, |
| {25, 1}, |
| {.3f, std::numeric_limits<float>::quiet_NaN()}}, |
| 3, |
| CellFillMode::kStretch}, // Flat CONIC with a cusp |
| {{{1, 1}, |
| {70, 1}, |
| {25, 1}, |
| {1.5f, std::numeric_limits<float>::quiet_NaN()}}, |
| 3, |
| CellFillMode::kStretch}, // Flat CONIC with a cusp |
| }; |
| |
| static AABB calc_tight_cubic_bounds(const Vec2D P[4], int depth = 5) |
| { |
| if (0 == depth) |
| { |
| AABB bounds; |
| bounds.minX = |
| std::min(std::min(P[0].x, P[1].x), std::min(P[2].x, P[3].x)); |
| bounds.minY = |
| std::min(std::min(P[0].y, P[1].y), std::min(P[2].y, P[3].y)); |
| bounds.maxX = |
| std::max(std::max(P[0].x, P[1].x), std::max(P[2].x, P[3].x)); |
| bounds.maxY = |
| std::max(std::max(P[0].y, P[1].y), std::max(P[2].y, P[3].y)); |
| return bounds; |
| } |
| |
| Vec2D chopped[7]; |
| math::chop_cubic_at(P, chopped, .5f); |
| AABB bounds0 = calc_tight_cubic_bounds(chopped, depth - 1); |
| AABB bounds1 = calc_tight_cubic_bounds(chopped + 3, depth - 1); |
| if (bounds1.isEmptyOrNaN()) |
| { |
| return bounds0; |
| } |
| if (bounds0.isEmptyOrNaN()) |
| { |
| return bounds1; |
| } |
| bounds0.expand(bounds1); |
| return bounds0; |
| } |
| |
| static Vec2D lerp(const Vec2D& a, const Vec2D& b, float T) |
| { |
| assert(1 != T); // The below does not guarantee lerp(a, b, 1) === b. |
| return (b - a) * T + a; |
| } |
| |
| enum class FillMode |
| { |
| kCenter, |
| kScale |
| }; |
| |
| class TrickyCubicsGM : public GM |
| { |
| public: |
| TrickyCubicsGM(StrokeCap cap, StrokeJoin join, float feather) : |
| GM(kTestWidth, kTestHeight), |
| m_Cap(cap), |
| m_Join(join), |
| m_feather(feather) |
| {} |
| |
| ColorInt clearColor() const override { return 0xff000000; } |
| |
| void onDraw(rive::Renderer* renderer) override |
| { |
| Rand rand; |
| |
| Paint strokePaint; |
| strokePaint->style(RenderPaintStyle::stroke); |
| strokePaint->thickness(kStrokeWidth); |
| strokePaint->cap(m_Cap); |
| strokePaint->join(m_Join); |
| |
| for (size_t i = 0; i < std::size(kTrickyCubics); ++i) |
| { |
| auto [originalPts, numPts, fillMode, scale] = kTrickyCubics[i]; |
| |
| assert(numPts <= 4); |
| Vec2D p[4]; |
| memcpy(p, originalPts, sizeof(Vec2D) * numPts); |
| for (int j = 0; j < numPts; ++j) |
| { |
| p[j] *= scale; |
| } |
| |
| auto cellRect = AABB::fromLTWH((i % kNumCols) * kCellSize, |
| (int)(i / kNumCols) * kCellSize, |
| kCellSize, |
| kCellSize); |
| |
| AABB strokeBounds; |
| if (numPts == 4) |
| { |
| strokeBounds = calc_tight_cubic_bounds(p); |
| } |
| else |
| { |
| assert(numPts == 3); |
| Vec2D asCubic[4] = {p[0], |
| lerp(p[0], p[1], 2 / 3.f), |
| lerp(p[1], p[2], 1 / 3.f), |
| p[2]}; |
| strokeBounds = calc_tight_cubic_bounds(asCubic); |
| } |
| strokeBounds = strokeBounds.inset(-kStrokeWidth, -kStrokeWidth); |
| |
| Mat2D matrix; |
| if (fillMode == CellFillMode::kStretch) |
| { |
| matrix = rive::computeAlignment(Fit::contain, |
| Alignment::center, |
| cellRect, |
| strokeBounds); |
| } |
| else |
| { |
| matrix = Mat2D::fromTranslate( |
| cellRect.minX + kStrokeWidth + |
| (cellRect.width() - strokeBounds.width()) / 2, |
| cellRect.minY + kStrokeWidth + |
| (cellRect.height() - strokeBounds.height()) / 2); |
| } |
| |
| renderer->save(); |
| renderer->transform(matrix); |
| strokePaint->thickness(kStrokeWidth / matrix.findMaxScale()); |
| strokePaint->color(rand.u32() | 0xff808080); |
| Path path; |
| path->moveTo(p[0].x, p[0].y); |
| if (numPts == 4) |
| { |
| path->cubicTo(p[1].x, p[1].y, p[2].x, p[2].y, p[3].x, p[3].y); |
| } |
| else |
| { |
| assert(numPts == 3); |
| Vec2D c0 = p[0] + (p[1] - p[0]) * (2 / 3.f); |
| Vec2D c1 = p[2] + (p[1] - p[2]) * (2 / 3.f); |
| path->cubicTo(c0.x, c0.y, c1.x, c1.y, p[2].x, p[2].y); |
| } |
| if (m_feather != 0) |
| { |
| strokePaint->feather(m_feather / matrix.findMaxScale()); |
| } |
| renderer->drawPath(path, strokePaint); |
| renderer->restore(); |
| } |
| } |
| |
| private: |
| StrokeCap m_Cap; |
| StrokeJoin m_Join; |
| float m_feather; |
| }; |
| |
| GMREGISTER(trickycubicstrokes, |
| return new TrickyCubicsGM(StrokeCap::butt, StrokeJoin::miter, 0)) |
| GMREGISTER(trickycubicstrokes_roundcaps, |
| return new TrickyCubicsGM(StrokeCap::round, StrokeJoin::round, 0)) |
| // Feathers ignore cap and join. |
| GMREGISTER(trickycubicstrokes_feather, |
| return new TrickyCubicsGM(StrokeCap::butt, StrokeJoin::miter, 20)) |
