react-native-tgfx 0.0.0 → 0.0.2-alpha.0

package/cpp/third_party/tgfx/src/core/Canvas.cpp

@@ -0,0 +1,781 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2023 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "tgfx/core/Canvas.h"
+#include "core/CanvasState.h"
+#include "core/ClipStack.h"
+#include "core/DrawContext.h"
+#include "core/LayerUnrollContext.h"
+#include "core/PictureContext.h"
+#include "core/shapes/StrokeShape.h"
+#include "core/utils/Log.h"
+#include "core/utils/MathExtra.h"
+#include "core/utils/StrokeUtils.h"
+#include "core/utils/Types.h"
+#include "images/SubsetImage.h"
+#include "shapes/MatrixShape.h"
+#include "shapes/PathShape.h"
+#include "tgfx/core/Surface.h"
+
+namespace tgfx {
+
+class AutoLayerForImageFilter {
+ public:
+  AutoLayerForImageFilter(Canvas* canvas, std::shared_ptr<ImageFilter> imageFilter)
+      : canvas(canvas) {
+    if (imageFilter != nullptr) {
+      Paint layerPaint = {};
+      layerPaint.setImageFilter(std::move(imageFilter));
+      savedCount = canvas->saveLayer(&layerPaint);
+    }
+  }
+
+  ~AutoLayerForImageFilter() {
+    if (savedCount >= 0) {
+      canvas->restoreToCount(savedCount);
+    }
+  }
+
+ private:
+  Canvas* canvas = nullptr;
+  int savedCount = -1;
+};
+
+#define SaveLayerForImageFilter(imageFilter)                                        \
+  std::unique_ptr<AutoLayerForImageFilter> autoLayer = nullptr;                     \
+  if (auto filter = imageFilter) {                                                  \
+    autoLayer = std::make_unique<AutoLayerForImageFilter>(this, std::move(filter)); \
+  }
+
+static Brush GetBrushForImage(const Paint* paint, const Image* image) {
+  if (paint == nullptr) {
+    return {};
+  }
+  auto brush = paint->getBrush();
+  if (!image->isAlphaOnly()) {
+    brush.shader = nullptr;
+  }
+  return brush;
+}
+
+Canvas::Canvas(DrawContext* drawContext, Surface* surface)
+    : drawContext(drawContext), surface(surface) {
+  clipStack = std::make_unique<ClipStack>();
+}
+
+Canvas::~Canvas() = default;
+
+int Canvas::save() {
+  stateStack.push(std::make_unique<CanvasState>(_matrix));
+  clipStack->save();
+  return static_cast<int>(stateStack.size()) - 1;
+}
+
+int Canvas::saveLayer(const Paint* paint) {
+  auto layer = std::make_unique<CanvasLayer>(drawContext, paint);
+  drawContext = layer->layerContext.get();
+  stateStack.push(std::make_unique<CanvasState>(_matrix, std::move(layer)));
+  clipStack->save();
+  return static_cast<int>(stateStack.size()) - 1;
+}
+
+int Canvas::saveLayerAlpha(float alpha) {
+  Paint paint = {};
+  paint.setAlpha(alpha);
+  return saveLayer(&paint);
+}
+
+void Canvas::restore() {
+  if (stateStack.empty()) {
+    return;
+  }
+  auto& canvasState = stateStack.top();
+  _matrix = canvasState->matrix;
+  clipStack->restore();
+  auto layer = std::move(canvasState->savedLayer);
+  stateStack.pop();
+  if (layer != nullptr) {
+    drawContext = layer->drawContext;
+    auto layerContext = reinterpret_cast<PictureContext*>(layer->layerContext.get());
+    auto picture = layerContext->finishRecordingAsPicture();
+    if (picture != nullptr) {
+      drawLayer(std::move(picture), Matrix::I(), {}, layer->layerPaint.getBrush(),
+                layer->layerPaint.getImageFilter());
+    }
+  }
+}
+
+int Canvas::getSaveCount() const {
+  return static_cast<int>(stateStack.size());
+}
+
+void Canvas::restoreToCount(int saveCount) {
+  if (saveCount < 0) {
+    saveCount = 0;
+  }
+  auto count = stateStack.size() - static_cast<size_t>(saveCount);
+  for (size_t i = 0; i < count; i++) {
+    restore();
+  }
+}
+
+void Canvas::translate(float dx, float dy) {
+  _matrix.preTranslate(dx, dy);
+}
+
+void Canvas::scale(float sx, float sy) {
+  _matrix.preScale(sx, sy);
+}
+
+void Canvas::rotate(float degrees) {
+  _matrix.preRotate(degrees);
+}
+
+void Canvas::rotate(float degrees, float px, float py) {
+  Matrix m = {};
+  m.setRotate(degrees, px, py);
+  _matrix.preConcat(m);
+}
+
+void Canvas::skew(float sx, float sy) {
+  _matrix.preSkew(sx, sy);
+}
+
+void Canvas::concat(const Matrix& matrix) {
+  _matrix.preConcat(matrix);
+}
+
+void Canvas::setMatrix(const Matrix& matrix) {
+  _matrix = matrix;
+}
+
+void Canvas::resetMatrix() {
+  _matrix.reset();
+}
+
+const Matrix& Canvas::getMatrix() const {
+  return _matrix;
+}
+
+Path Canvas::getTotalClip() const {
+  return clipStack->getClipPath();
+}
+
+std::optional<Rect> Canvas::getTotalClipBounds() const {
+  if (clipStack->state() == ClipState::WideOpen) {
+    return std::nullopt;
+  }
+  return clipStack->bounds();
+}
+
+void Canvas::clipRect(const Rect& rect, bool antiAlias) {
+  clipStack->clipRect(rect, _matrix, antiAlias);
+}
+
+void Canvas::clipRRect(const RRect& rRect, bool antiAlias) {
+  clipStack->clipRRect(rRect, _matrix, antiAlias);
+}
+
+void Canvas::clipPath(const Path& path, bool antiAlias) {
+  if (path.isInverseFillType()) {
+    // Inverse-fill paths cannot be expressed as a simple rect/rrect clip, so fall back to path.
+    clipStack->clipPath(path, _matrix, antiAlias);
+    return;
+  }
+
+  if (Rect rect = {}; path.isRect(&rect)) {
+    clipStack->clipRect(rect, _matrix, antiAlias);
+    return;
+  }
+  // Ovals and general RRects are treated as separate types, so handle ovals separately.
+  if (Rect ovalBounds = {}; path.isOval(&ovalBounds)) {
+    clipStack->clipRRect(RRect::MakeOval(ovalBounds), _matrix, antiAlias);
+    return;
+  }
+  if (RRect rRect = {}; path.isRRect(&rRect)) {
+    clipStack->clipRRect(rRect, _matrix, antiAlias);
+    return;
+  }
+  clipStack->clipPath(path, _matrix, antiAlias);
+}
+
+void Canvas::resetStateStack() {
+  _matrix = Matrix::I();
+  std::stack<std::unique_ptr<CanvasState>>().swap(stateStack);
+  clipStack = std::make_unique<ClipStack>();
+}
+
+void Canvas::clear(const Color& color) {
+  drawColor(color, BlendMode::Src);
+}
+
+void Canvas::drawColor(const Color& color, BlendMode blendMode) {
+  drawFill(_matrix, *clipStack, {color, blendMode, false});
+}
+
+void Canvas::drawPaint(const Paint& paint) {
+  SaveLayerForImageFilter(paint.getImageFilter());
+  drawFill(_matrix, *clipStack, paint.getBrush());
+}
+
+void Canvas::drawLine(float x0, float y0, float x1, float y1, const Paint& paint) {
+  SaveLayerForImageFilter(paint.getImageFilter());
+  Stroke stroke(paint.getStrokeWidth(), paint.getLineCap(), paint.getLineJoin(),
+                paint.getMiterLimit());
+  Point line[2] = {{x0, y0}, {x1, y1}};
+  drawLine(line, _matrix, *clipStack, paint.getBrush(), stroke);
+}
+
+void Canvas::drawLine(const Point line[2], const Matrix& matrix, const ClipStack& clip,
+                      const Brush& brush, const Stroke& stroke) const {
+  Rect rect = {};
+  if (StrokeLineToRect(stroke, line, &rect)) {
+    drawContext->drawRect(rect, matrix, clip, brush, nullptr);
+    return;
+  }
+  RRect rRect = {};
+  if (StrokeLineToRRect(stroke, line, &rRect)) {
+    drawContext->drawRRect(rRect, matrix, clip, brush, nullptr);
+    return;
+  }
+  Path path = {};
+  path.moveTo(line[0].x, line[0].y);
+  path.lineTo(line[1].x, line[1].y);
+  auto shape = Shape::MakeFrom(path);
+  if (shape) {
+    drawContext->drawShape(shape, matrix, clip, brush, &stroke);
+  }
+}
+
+void Canvas::drawRect(const Rect& rect, const Paint& paint) {
+  if (rect.isEmpty()) {
+    if (paint.getStyle() != PaintStyle::Stroke) {
+      return;
+    }
+    Path path = {};
+    path.addRect(rect);
+    drawPath(path, paint);
+    return;
+  }
+  SaveLayerForImageFilter(paint.getImageFilter());
+  drawContext->drawRect(rect, _matrix, *clipStack, paint.getBrush(), paint.getStroke());
+}
+
+void Canvas::drawOval(const Rect& oval, const Paint& paint) {
+  drawRRect(RRect::MakeOval(oval), paint);
+}
+
+void Canvas::drawCircle(float centerX, float centerY, float radius, const Paint& paint) {
+  Rect rect =
+      Rect::MakeLTRB(centerX - radius, centerY - radius, centerX + radius, centerY + radius);
+  drawOval(rect, paint);
+}
+
+void Canvas::drawRoundRect(const Rect& rect, float radiusX, float radiusY, const Paint& paint) {
+  drawRRect(RRect::MakeRectXY(rect, radiusX, radiusY), paint);
+}
+
+// The sub-half-pixel threshold classifies a corner as "sharp" only when the arc would be
+// shorter than one device pixel; therefore the local radius must be projected to device space
+// via the current CTM's max scale before comparison. Without this, a tiny local-space radius
+// inside a large scale-up (e.g. a 0.9-unit oval under 100x) is wrongly treated as sharp and
+// the dedicated RRect op is bypassed.
+static bool HasSharpCorner(const RRect& rRect, const Matrix& viewMatrix) {
+  auto deviceScale = viewMatrix.getMaxScale();
+  if (FloatNearlyZero(deviceScale)) {
+    return true;
+  }
+  for (const auto& r : rRect.radii()) {
+    if (r.x * deviceScale < 0.5f || r.y * deviceScale < 0.5f) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Returns true when either diagonal corner pair has overlapping arc-center boxes on at least
+// one axis, i.e. its x-radii or y-radii sum exceeds the corresponding side length.
+static bool HasDiagonalCornerAxisOverlap(const RRect& rRect) {
+  if (!rRect.isComplex()) {
+    return false;
+  }
+  const auto& r = rRect.radii();
+  const auto w = rRect.rect().width();
+  const auto h = rRect.rect().height();
+  return r[0].x + r[2].x > w || r[0].y + r[2].y > h || r[1].x + r[3].x > w || r[1].y + r[3].y > h;
+}
+
+/**
+ * The dedicated RRect op draws stroked rounded corners by offsetting the ellipse equation
+ * outward/inward, which assumes a concentric ellipse approximates the true stroke offset
+ * curve. The approximation breaks down when the stroke is too thick relative to the corner
+ * radii, or when the ellipse is too elongated (major/minor ratio too large). In those cases
+ * this function returns true so the caller falls back to drawPath for an accurate stroke.
+ */
+static bool UseDrawPath(const Stroke* stroke, const RRect& rRect, bool hasSharpCorner,
+                        const Matrix& viewMatrix) {
+  // Sharp corners (sub-half-unit local radius on either axis) make the ellipse implicit
+  // equation degenerate: at zero radius the equation is undefined, and under stroke the
+  // inner ellipse radius would become negative. Fall back to drawPath so the sharp
+  // geometry renders correctly.
+  if (hasSharpCorner) {
+    return true;
+  }
+  // The AA path partitions the RRect into a 4x4 grid of quads; a diagonal corner pair
+  // overlapping on either axis makes those quads self-intersect. The NonAA path is free of
+  // that mesh constraint but its shader still miscomputes coverage when diagonal corner
+  // boxes truly overlap. We cannot tell here which path the op will take, so apply the
+  // stricter AA rule and fall back to drawPath whenever any axis is crossed.
+  if (HasDiagonalCornerAxisOverlap(rRect)) {
+    return true;
+  }
+  if (!stroke) {
+    return false;
+  }
+
+  const auto scales = viewMatrix.getAxisScales();
+  // Per-axis scaled stroke width: local width multiplied by the x/y axis scale factors
+  // extracted from the view matrix.
+  const Point scaledStroke = {scales.x * stroke->width, scales.y * stroke->width};
+  Point halfScaledStroke = {};
+  if (FloatNearlyZero(scaledStroke.length())) {
+    // Hairline stroke (width == 0) falls back to half a pixel on each axis.
+    halfScaledStroke = {0.5f, 0.5f};
+  } else {
+    halfScaledStroke = scaledStroke * 0.5f;
+  }
+  const auto halfScaledStrokeLen = halfScaledStroke.length();
+
+  // Non-Complex types have identical radii across all four corners (zero for Rect, equal
+  // per-corner for Simple/Oval), so only the first needs check.
+  const auto cornerCount = rRect.isComplex() ? rRect.radii().size() : size_t{1};
+  for (size_t i = 0; i < cornerCount; ++i) {
+    const auto& r = rRect.radii()[i];
+    const auto xRadius = scales.x * r.x;
+    const auto yRadius = scales.y * r.y;
+    // Half stroke width exceeds corner radius: the inner offset ellipse collapses
+    // (inner radius would be non-positive), so the concentric-ellipse approximation
+    // cannot be constructed.
+    if (halfScaledStroke.x > xRadius || halfScaledStroke.y > yRadius) {
+      return true;
+    }
+    // Thick stroke on an elongated ellipse (major/minor axis ratio > 2): the concentric-ellipse
+    // approximation visibly diverges from the true offset curve.
+    if (halfScaledStrokeLen > 0.5f && (0.5f * xRadius > yRadius || 0.5f * yRadius > xRadius)) {
+      return true;
+    }
+    // Stroke width exceeds the ellipse's local curvature radius at a short-axis endpoint
+    // (b*b/a on x-axis, a*a/b on y-axis). The inner offset curve would self-intersect,
+    // so the concentric-ellipse approximation breaks down.
+    if (halfScaledStroke.x * yRadius * yRadius <
+        halfScaledStroke.y * halfScaledStroke.y * xRadius) {
+      return true;
+    }
+    if (halfScaledStroke.y * xRadius * xRadius <
+        halfScaledStroke.x * halfScaledStroke.x * yRadius) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void Canvas::drawRRect(const RRect& rRect, const Paint& paint) {
+  if (rRect.rect().isEmpty()) {
+    drawRect(rRect.rect(), paint);
+    return;
+  }
+  // Classify corner radii in a single pass so both the allSmall degenerate check and the
+  // anySmall op-capability check share one traversal. The sub-half-pixel threshold is evaluated
+  // in device space, so the local radii are scaled by the current CTM's max scale before
+  // comparing. Otherwise a layer-local small RRect inside a scaled-up parent (e.g. a 0.9x0.9
+  // oval inside a 100x scale) would be wrongly degenerated into a rect even though its arcs
+  // are clearly visible after the transform. A singular CTM (max scale == 0) projects all
+  // geometry to a zero-area region, so nothing visible would be drawn anyway.
+  auto deviceScale = _matrix.getMaxScale();
+  if (FloatNearlyZero(deviceScale)) {
+    return;
+  }
+  auto allSmall = true;
+  auto anySmall = false;
+  for (const auto& r : rRect.radii()) {
+    if (r.x * deviceScale < 0.5f || r.y * deviceScale < 0.5f) {
+      anySmall = true;
+    } else {
+      allSmall = false;
+    }
+  }
+  if (allSmall) {
+    drawRect(rRect.rect(), paint);
+    return;
+  }
+  if (UseDrawPath(paint.getStroke(), rRect, anySmall, _matrix)) {
+    Path path = {};
+    path.addRRect(rRect);
+    drawPath(path, paint);
+    return;
+  }
+  SaveLayerForImageFilter(paint.getImageFilter());
+  drawContext->drawRRect(rRect, _matrix, *clipStack, paint.getBrush(), paint.getStroke());
+}
+
+void Canvas::drawPath(const Path& path, const Paint& paint) {
+  SaveLayerForImageFilter(paint.getImageFilter());
+  if (path.isEmpty()) {
+    if (path.isInverseFillType()) {
+      // No geometry to draw, so draw the fill instead.
+      drawFill(_matrix, *clipStack, paint.getBrush());
+    }
+    return;
+  }
+  drawPath(path, _matrix, *clipStack, paint.getBrush(), paint.getStroke());
+}
+
+void Canvas::drawPath(const Path& path, const Matrix& matrix, const ClipStack& clip,
+                      const Brush& brush, const Stroke* stroke) const {
+  DEBUG_ASSERT(!path.isEmpty());
+  Point line[2] = {};
+  if (path.isLine(line)) {
+    if (!stroke) {
+      return;
+    }
+    drawLine(line, matrix, clip, brush, *stroke);
+    return;
+  }
+  Rect rect = {};
+  bool closed = false;
+  // isRect can match an open 4-segment polyline whose stroke (open contour with caps) differs
+  // from a closed rectangle stroke, so only forward when the path is closed or there is no
+  // stroke (closedness does not affect fill).
+  if (path.isRect(&rect, &closed) && !rect.isEmpty() && (stroke == nullptr || closed)) {
+    drawContext->drawRect(rect, matrix, clip, brush, stroke);
+    return;
+  }
+  RRect rRect = {};
+  bool hasRRect = false;
+  // Path::isOval can return true with empty bounds because addOval does not filter them, so
+  // guard against an empty oval reaching the backend (which asserts on empty rrects).
+  if (path.isOval(&rect) && !rect.isEmpty()) {
+    rRect.setOval(rect);
+    hasRRect = true;
+  } else if (path.isRRect(&rRect) && !rRect.rect().isEmpty()) {
+    hasRRect = true;
+  }
+  // UseDrawPath forces complex stroke/radius combinations through the generic stroker, matching
+  // the drawRRect entry point.
+  if (hasRRect && !UseDrawPath(stroke, rRect, HasSharpCorner(rRect, matrix), matrix)) {
+    drawContext->drawRRect(rRect, matrix, clip, brush, stroke);
+    return;
+  }
+  if (stroke == nullptr) {
+    drawContext->drawPath(path, matrix, clip, brush);
+    return;
+  }
+  auto shape = Shape::MakeFrom(path);
+  if (shape == nullptr) {
+    return;
+  }
+  drawContext->drawShape(shape, matrix, clip, brush, stroke);
+}
+
+void Canvas::drawShape(std::shared_ptr<Shape> shape, const Paint& paint) {
+  if (shape == nullptr) {
+    return;
+  }
+  SaveLayerForImageFilter(paint.getImageFilter());
+  auto brush = paint.getBrush();
+  auto drawMatrix = _matrix;
+  auto stroke = paint.getStroke();
+  Path* path = nullptr;
+  if (shape->type() == Shape::Type::Path) {
+    path = &std::static_pointer_cast<PathShape>(shape)->path;
+  } else if (stroke == nullptr && shape->type() == Shape::Type::Matrix) {
+    auto matrixShape = std::static_pointer_cast<MatrixShape>(shape);
+    if (matrixShape->shape->isSimplePath()) {
+      Matrix inverse = {};
+      if (matrixShape->matrix.invert(&inverse)) {
+        path = &std::static_pointer_cast<PathShape>(matrixShape->shape)->path;
+        drawMatrix.preConcat(matrixShape->matrix);
+        brush = brush.makeWithMatrix(inverse);
+      }
+    }
+  }
+  if (path) {
+    if (path->isEmpty()) {
+      if (path->isInverseFillType()) {
+        // No geometry to draw, so draw the fill instead.
+        drawFill(drawMatrix, *clipStack, brush);
+      }
+    } else {
+      drawPath(*path, drawMatrix, *clipStack, brush, stroke);
+    }
+    return;
+  }
+  drawContext->drawShape(std::move(shape), drawMatrix, *clipStack, brush, stroke);
+}
+
+void Canvas::drawMesh(std::shared_ptr<Mesh> mesh, const Paint& paint) {
+  if (mesh == nullptr) {
+    return;
+  }
+  SaveLayerForImageFilter(paint.getImageFilter());
+  drawContext->drawMesh(std::move(mesh), _matrix, *clipStack, paint.getBrush());
+}
+
+void Canvas::drawImage(std::shared_ptr<Image> image, const SamplingOptions& sampling,
+                       const Paint* paint) {
+  if (image == nullptr) {
+    return;
+  }
+  SaveLayerForImageFilter(paint ? paint->getImageFilter() : nullptr);
+  auto brush = GetBrushForImage(paint, image.get());
+  drawImage(std::move(image), brush, sampling, nullptr);
+}
+
+void Canvas::drawImage(std::shared_ptr<Image> image, float left, float top,
+                       const SamplingOptions& sampling, const Paint* paint) {
+  if (image == nullptr) {
+    return;
+  }
+  SaveLayerForImageFilter(paint ? paint->getImageFilter() : nullptr);
+  auto brush = GetBrushForImage(paint, image.get());
+  auto dstMatrix = Matrix::MakeTrans(left, top);
+  drawImage(std::move(image), brush, sampling, &dstMatrix);
+}
+
+void Canvas::drawImageRect(std::shared_ptr<Image> image, const Rect& dstRect,
+                           const SamplingOptions& sampling, const Paint* paint) {
+  if (image == nullptr) {
+    return;
+  }
+  auto srcRect = Rect::MakeWH(image->width(), image->height());
+  drawImageRect(std::move(image), srcRect, dstRect, sampling, paint);
+}
+
+void Canvas::drawImageRect(std::shared_ptr<Image> image, const Rect& srcRect, const Rect& dstRect,
+                           const SamplingOptions& sampling, const Paint* paint,
+                           SrcRectConstraint constraint, const Rect* strictRect) {
+  if (image == nullptr || srcRect.isEmpty() || dstRect.isEmpty()) {
+    return;
+  }
+  SaveLayerForImageFilter(paint ? paint->getImageFilter() : nullptr);
+  auto brush = GetBrushForImage(paint, image.get());
+  drawImageRect(std::move(image), srcRect, dstRect, sampling, brush, constraint, strictRect);
+}
+
+void Canvas::drawImage(std::shared_ptr<Image> image, const Brush& brush,
+                       const SamplingOptions& sampling, const Matrix* dstMatrix) {
+  DEBUG_ASSERT(image != nullptr);
+  auto type = Types::Get(image.get());
+  auto drawMatrix = _matrix;
+  auto newBrush = brush;
+  if (dstMatrix) {
+    drawMatrix.preConcat(*dstMatrix);
+    auto brushMatrix = Matrix::I();
+    if (!dstMatrix->invert(&brushMatrix)) {
+      return;
+    }
+    newBrush = brush.makeWithMatrix(brushMatrix);
+  }
+  if (type != Types::ImageType::Subset || image->hasMipmaps()) {
+    drawContext->drawImage(std::move(image), sampling, drawMatrix, *clipStack, newBrush);
+    return;
+  }
+  auto subsetImage = static_cast<const SubsetImage*>(image.get());
+  auto& subset = subsetImage->bounds;
+  drawContext->drawImageRect(subsetImage->source, subset,
+                             Rect::MakeWH(image->width(), image->height()), sampling, drawMatrix,
+                             *clipStack, newBrush, SrcRectConstraint::Strict);
+}
+
+// Fills a rectangle with the given Image. The image is sampled from the area defined by rect,
+// and rendered into the same area, transformed by extraMatrix and the current matrix.
+void Canvas::drawImageRect(std::shared_ptr<Image> image, const Rect& srcRect, const Rect& dstRect,
+                           const SamplingOptions& sampling, const Brush& brush,
+                           SrcRectConstraint constraint, const Rect* strictRect) {
+  DEBUG_ASSERT(image != nullptr);
+  DEBUG_ASSERT(!srcRect.isEmpty());
+  DEBUG_ASSERT(!dstRect.isEmpty());
+  auto type = Types::Get(image.get());
+  if (type != Types::ImageType::Subset || image->hasMipmaps()) {
+    drawContext->drawImageRect(std::move(image), srcRect, dstRect, sampling, _matrix, *clipStack,
+                               brush, constraint, strictRect);
+    return;
+  }
+  auto imageRect = srcRect;
+  std::optional<Rect> adjustedStrictRect =
+      strictRect ? std::optional<Rect>(*strictRect) : std::nullopt;
+  auto safeBounds = Rect::MakeWH(image->width(), image->height());
+  safeBounds.inset(0.5f, 0.5f);
+  if (constraint == SrcRectConstraint::Strict || safeBounds.contains(srcRect)) {
+    // Unwrap the subset image to maximize the merging of draw calls.
+    auto subsetImage = static_cast<const SubsetImage*>(image.get());
+    auto& subset = subsetImage->bounds;
+    imageRect.offset(subset.left, subset.top);
+    // strictRect lives in the SubsetImage coordinate space; translate it together with imageRect
+    // so the shader's clamp range stays in the unwrapped source coordinate space.
+    if (adjustedStrictRect) {
+      adjustedStrictRect->offset(subset.left, subset.top);
+    }
+    image = subsetImage->source;
+  }
+  drawContext->drawImageRect(std::move(image), imageRect, dstRect, sampling, _matrix, *clipStack,
+                             brush, constraint,
+                             adjustedStrictRect ? &*adjustedStrictRect : nullptr);
+}
+
+void Canvas::drawSimpleText(const std::string& text, float x, float y, const Font& font,
+                            const Paint& paint) {
+  if (text.empty()) {
+    return;
+  }
+  auto textBlob = TextBlob::MakeFrom(text, font);
+  drawTextBlob(std::move(textBlob), x, y, paint);
+}
+
+void Canvas::drawGlyphs(const GlyphID glyphs[], const Point positions[], size_t glyphCount,
+                        const Font& font, const Paint& paint) {
+
+  if (glyphCount == 0) {
+    return;
+  }
+  SaveLayerForImageFilter(paint.getImageFilter());
+  auto textBlob = TextBlob::MakeFrom(glyphs, positions, glyphCount, font);
+  if (textBlob == nullptr) {
+    return;
+  }
+  drawContext->drawTextBlob(std::move(textBlob), _matrix, *clipStack, paint.getBrush(),
+                            paint.getStroke());
+}
+
+void Canvas::drawTextBlob(std::shared_ptr<TextBlob> textBlob, float x, float y,
+                          const Paint& paint) {
+  if (textBlob == nullptr) {
+    return;
+  }
+  SaveLayerForImageFilter(paint.getImageFilter());
+  auto drawMatrix = _matrix;
+  if (!FloatNearlyZero(x) || !FloatNearlyZero(y)) {
+    drawMatrix.preTranslate(x, y);
+    auto brush = paint.getBrush().makeWithMatrix(Matrix::MakeTrans(-x, -y));
+    drawContext->drawTextBlob(std::move(textBlob), drawMatrix, *clipStack, brush,
+                              paint.getStroke());
+  } else {
+    drawContext->drawTextBlob(std::move(textBlob), drawMatrix, *clipStack, paint.getBrush(),
+                              paint.getStroke());
+  }
+}
+
+void Canvas::drawPicture(std::shared_ptr<Picture> picture) {
+  if (picture == nullptr) {
+    return;
+  }
+  drawContext->drawPicture(std::move(picture), _matrix, *clipStack);
+}
+
+void Canvas::drawPicture(std::shared_ptr<Picture> picture, const Matrix* matrix,
+                         const Paint* paint) {
+  if (picture == nullptr) {
+    return;
+  }
+  auto drawMatrix = _matrix;
+  if (matrix) {
+    drawMatrix.preConcat(*matrix);
+  }
+  if (paint) {
+    auto brush = paint->getBrush();
+    brush.shader = nullptr;
+    drawLayer(std::move(picture), drawMatrix, *clipStack, brush, paint->getImageFilter());
+  } else {
+    drawContext->drawPicture(std::move(picture), drawMatrix, *clipStack);
+  }
+}
+
+void Canvas::drawLayer(std::shared_ptr<Picture> picture, const Matrix& matrix,
+                       const ClipStack& clip, const Brush& brush,
+                       std::shared_ptr<ImageFilter> imageFilter) {
+  DEBUG_ASSERT(brush.shader == nullptr);
+  DEBUG_ASSERT(picture != nullptr);
+  if (imageFilter != nullptr) {
+    Point offset = {};
+    if (auto image = picture->asImage(&offset)) {
+      Point filterOffset = {};
+      image = image->makeWithFilter(std::move(imageFilter), &filterOffset);
+      if (image == nullptr) {
+        LOGE("Canvas::drawLayer() Failed to apply filter to image!");
+        return;
+      }
+      auto drawMatrix = matrix;
+      drawMatrix.preTranslate(offset.x + filterOffset.x, offset.y + filterOffset.y);
+      auto brushMatrix = Matrix::MakeTrans(-offset.x - filterOffset.x, -offset.y - filterOffset.y);
+      drawContext->drawImage(std::move(image), {}, drawMatrix, clip,
+                             brush.makeWithMatrix(brushMatrix));
+      return;
+    }
+  } else if (picture->drawCount == 1 && brush.maskFilter == nullptr) {
+    LayerUnrollContext unrollContext(drawContext, brush);
+    picture->playback(&unrollContext, matrix, clip);
+    if (unrollContext.hasUnrolled()) {
+      return;
+    }
+  }
+  drawContext->drawLayer(std::move(picture), std::move(imageFilter), matrix, clip, brush);
+}
+
+void Canvas::drawAtlas(std::shared_ptr<Image> atlas, const Matrix matrix[], const Rect tex[],
+                       const Color colors[], size_t count, const SamplingOptions& sampling,
+                       const Paint* paint) {
+  // TODO: Support blend mode, atlas as source, colors as destination, colors can be nullptr.
+  if (atlas == nullptr || count == 0) {
+    return;
+  }
+  auto brush = GetBrushForImage(paint, atlas.get());
+  SaveLayerForImageFilter(paint ? paint->getImageFilter() : nullptr);
+  auto atlasRect = Rect::MakeWH(atlas->width(), atlas->height());
+  for (size_t i = 0; i < count; ++i) {
+    auto rect = tex[i];
+    if (!rect.intersect(atlasRect)) {
+      continue;
+    }
+    auto dstMatrix = matrix[i];
+    dstMatrix.preTranslate(-rect.x(), -rect.y());
+    auto glyphBrush = brush;
+    if (colors) {
+      glyphBrush.color = colors[i];
+    }
+    auto dstRect = dstMatrix.mapRect(rect);
+    drawImageRect(atlas, rect, dstRect, sampling, glyphBrush);
+  }
+}
+
+void Canvas::drawFill(const Matrix& matrix, const ClipStack& clip, const Brush& brush) const {
+  if (clip.state() == ClipState::Empty) {
+    return;
+  }
+  auto clipBrush = brush.makeWithMatrix(matrix);
+  if (clip.state() == ClipState::WideOpen) {
+    clipBrush.antiAlias = false;
+    drawContext->drawFill(clipBrush);
+  } else {
+    // Use an empty inverse path to fill the entire area, clipped by the current clip.
+    Path path = {};
+    path.setFillType(PathFillType::InverseWinding);
+    drawContext->drawPath(path, Matrix::I(), clip, clipBrush);
+  }
+}
+
+}  // namespace tgfx