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

package/cpp/third_party/tgfx/src/gpu/OpsCompositor.cpp

@@ -0,0 +1,1198 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2025 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 "OpsCompositor.h"
+#include "core/MeshBase.h"
+#include "core/PathRef.h"
+#include "core/VertexMesh.h"
+#include "core/utils/ColorHelper.h"
+#include "core/utils/ColorSpaceHelper.h"
+#include "core/utils/GeometryExtra.h"
+#include "core/utils/MathExtra.h"
+#include "core/utils/RectToRectMatrix.h"
+#include "core/utils/StrokeUtils.h"
+#include "core/utils/USE.h"
+#include "gpu/DrawingManager.h"
+#include "gpu/ProxyProvider.h"
+#include "gpu/ops/AtlasTextOp.h"
+#include "gpu/ops/HairlineLineOp.h"
+#include "gpu/ops/HairlineQuadOp.h"
+#include "gpu/ops/MeshDrawOp.h"
+#include "gpu/ops/ShapeDrawOp.h"
+#include "gpu/ops/ShapeInstancedDrawOp.h"
+#include "gpu/ops/StencilCoverPathDrawOp.h"
+#include "gpu/processors/DeviceSpaceTextureEffect.h"
+#include "gpu/processors/RRectEffect.h"
+#include "gpu/processors/RectEffect.h"
+#include "processors/ColorSpaceXFormEffect.h"
+#include "processors/PorterDuffXferProcessor.h"
+#include "processors/XfermodeFragmentProcessor.h"
+#include "tgfx/gpu/GPU.h"
+
+namespace tgfx {
+
+static bool HasDifferentViewMatrix(const std::vector<PlacementPtr<RectRecord>>& rects) {
+  if (rects.size() <= 1) {
+    return false;
+  }
+  auto& firstMatrix = rects.front()->viewMatrix;
+  for (auto& record : rects) {
+    if (record->viewMatrix != firstMatrix) {
+      return true;
+    }
+  }
+  return false;
+}
+
+OpsCompositor::OpsCompositor(std::shared_ptr<RenderTargetProxy> proxy, uint32_t renderFlags,
+                             std::optional<PMColor> clearColor,
+                             std::shared_ptr<ColorSpace> colorSpace)
+    : context(proxy->getContext()), renderTarget(std::move(proxy)), renderFlags(renderFlags),
+      clearColor(clearColor), dstColorSpace(std::move(colorSpace)) {
+  DEBUG_ASSERT(renderTarget != nullptr);
+}
+
+void OpsCompositor::fillImage(std::shared_ptr<Image> image, const SamplingOptions& sampling,
+                              const Matrix& matrix, const ClipStack& clip, const Brush& brush) {
+  DEBUG_ASSERT(image != nullptr);
+  auto imageRect = Rect::MakeWH(image->width(), image->height());
+  if (!canAppend(PendingOpType::Image, clip, brush) || pendingImage != image ||
+      pendingSampling != sampling || pendingConstraint != SrcRectConstraint::Fast) {
+    flushPendingOps(PendingOpType::Image, clip, brush);
+    pendingImage = std::move(image);
+    pendingSampling = sampling;
+    pendingConstraint = SrcRectConstraint::Fast;
+  }
+  auto record = drawingAllocator()->make<RectRecord>(imageRect, matrix, brush.color);
+  pendingRects.emplace_back(std::move(record));
+  pendingUVRects.emplace_back(drawingAllocator()->make<Rect>(imageRect));
+}
+
+void OpsCompositor::fillImageRect(std::shared_ptr<Image> image, const Rect& srcRect,
+                                  const Rect& dstRect, const SamplingOptions& sampling,
+                                  const Matrix& matrix, const ClipStack& clip, const Brush& brush,
+                                  SrcRectConstraint constraint, const Rect* strictRect) {
+  DEBUG_ASSERT(image != nullptr);
+  DEBUG_ASSERT(!srcRect.isEmpty());
+  DEBUG_ASSERT(!dstRect.isEmpty());
+  auto brushInLocal = brush.makeWithMatrix(MakeRectToRectMatrix(dstRect, srcRect));
+  if (!canAppend(PendingOpType::Image, clip, brushInLocal) || pendingImage != image ||
+      pendingSampling != sampling || pendingConstraint != constraint) {
+    flushPendingOps(PendingOpType::Image, clip, brushInLocal);
+    pendingImage = std::move(image);
+    pendingSampling = sampling;
+    pendingConstraint = constraint;
+  }
+  auto record = drawingAllocator()->make<RectRecord>(dstRect, matrix, brushInLocal.color);
+  pendingRects.emplace_back(std::move(record));
+  pendingUVRects.emplace_back(drawingAllocator()->make<Rect>(srcRect));
+  // For Strict mode, track a per-rect subset rectangle, falling back to srcRect when strictRect is
+  // null. The parallel array keeps indices aligned with pendingRects, simplifying flush-time
+  // access. Non-Strict ops never reach the subset path (see flushPendingOps), so the extra
+  // memory is harmless.
+  if (constraint == SrcRectConstraint::Strict) {
+    pendingSubsetRects.emplace_back(
+        drawingAllocator()->make<Rect>(strictRect != nullptr ? *strictRect : srcRect));
+  }
+  if (!hasRectToRectDraw && srcRect != dstRect) {
+    hasRectToRectDraw = true;
+  }
+}
+
+static bool ShouldFlushRectOps(const std::vector<PlacementPtr<Stroke>>& pendingStrokes,
+                               const Stroke* stroke) {
+  if (pendingStrokes.empty()) {
+    return stroke != nullptr;
+  }
+  return stroke == nullptr || pendingStrokes.front()->join != stroke->join;
+}
+
+// Returns true when the new RRect's complexity (Complex vs non-Complex) disagrees with the
+// RRects already queued.
+static bool ComplexMismatch(const RRect& newRRect,
+                            const std::vector<PlacementPtr<RRectRecord>>& pending) {
+  if (pending.empty()) {
+    return false;
+  }
+  return newRRect.isComplex() != pending.front()->rRect.isComplex();
+}
+
+void OpsCompositor::fillRect(const Rect& rect, const Matrix& matrix, const ClipStack& clip,
+                             const Brush& brush, const Stroke* stroke) {
+  DEBUG_ASSERT(!rect.isEmpty());
+  if (!canAppend(PendingOpType::Rect, clip, brush) || ShouldFlushRectOps(pendingStrokes, stroke)) {
+    flushPendingOps(PendingOpType::Rect, clip, brush);
+  }
+
+  auto record = drawingAllocator()->make<RectRecord>(rect, matrix, brush.color);
+  pendingRects.emplace_back(std::move(record));
+  if (stroke) {
+    auto strokeRecord = drawingAllocator()->make<Stroke>(*stroke);
+    pendingStrokes.emplace_back(std::move(strokeRecord));
+  }
+}
+
+void OpsCompositor::drawRRect(const RRect& rRect, const Matrix& matrix, const ClipStack& clip,
+                              const Brush& brush, const Stroke* stroke) {
+  DEBUG_ASSERT(!rRect.rect().isEmpty());
+  auto rectBrush = brush.makeWithMatrix(matrix);
+  // Complex and non-Complex RRects use different GPs and vertex layouts, so they cannot be
+  // batched into the same op; flush if the incoming RRect's complexity disagrees with pending.
+  if (!canAppend(PendingOpType::RRect, clip, rectBrush) ||
+      ShouldFlushRectOps(pendingStrokes, stroke) || ComplexMismatch(rRect, pendingRRects)) {
+    flushPendingOps(PendingOpType::RRect, clip, rectBrush);
+  }
+  auto record = drawingAllocator()->make<RRectRecord>(rRect, matrix, rectBrush.color);
+  pendingRRects.emplace_back(std::move(record));
+  if (stroke) {
+    auto strokeRecord = drawingAllocator()->make<Stroke>(*stroke);
+    pendingStrokes.emplace_back(std::move(strokeRecord));
+  }
+}
+
+static Rect ClipLocalBounds(const Rect& localBounds, const Matrix& viewMatrix,
+                            const Rect& clipBounds) {
+  auto result = ToLocalBounds(clipBounds, viewMatrix);
+  if (!result.intersect(localBounds)) {
+    return {};
+  }
+  return result;
+}
+
+static bool MatrixOnlyDiffersInTranslation(const Matrix& a, const Matrix& b) {
+  // Exact floating-point comparison is intentional: we prefer missing a batch opportunity over
+  // incorrectly batching shapes with different non-translation transforms.
+  // [0]scaleX [1]skewX [2]transX [3]skewY [4]scaleY [5]transY [6]persp0 [7]persp1 [8]persp2
+  return a[0] == b[0] && a[1] == b[1] && a[3] == b[3] && a[4] == b[4] && a[6] == b[6] &&
+         a[7] == b[7] && a[8] == b[8];
+}
+
+void OpsCompositor::drawShape(std::shared_ptr<Shape> shape, const Matrix& matrix,
+                              const ClipStack& clip, const Brush& brush) {
+  DEBUG_ASSERT(shape != nullptr);
+  if (shouldUseStencilCover(brush)) {
+    if (!canAppend(PendingOpType::StencilCoverPath, clip, brush)) {
+      flushPendingOps(PendingOpType::StencilCoverPath, clip, brush);
+    }
+    // canAppend + CompareBrush ignore brush.color, so a run of stencil-cover shapes may
+    // legitimately differ only in color. Keep per-shape colors in a parallel array while
+    // pendingBrush stays pinned to the first shape's brush (its shader / blendMode /
+    // maskFilter / colorFilter are what canAppend actually validated). flushPendingStencil-
+    // CoverOps MUST feed dstColor from this array, not from pendingBrush.color.
+    pendingStencilCoverShapes.emplace_back(std::move(shape));
+    pendingStencilCoverMatrices.emplace_back(matrix);
+    pendingStencilCoverColors.emplace_back(brush.color);
+    return;
+  }
+  if (canAppend(PendingOpType::Shape, clip, brush) && pendingShape &&
+      pendingShape->getUniqueKey() == shape->getUniqueKey() &&
+      MatrixOnlyDiffersInTranslation(pendingShapeMatrix, matrix)) {
+    // Offset has two sources, both in device space:
+    // 1. Canvas matrix translation difference (already in device space).
+    // 2. Shape bounds difference (in local space, needs matrix linear transform to device space).
+    //    This occurs when tryAddSimplifiedMatrixShape encodes position into shape bounds
+    //    instead of the canvas matrix.
+    auto dx = matrix.getTranslateX() - pendingShapeMatrix.getTranslateX();
+    auto dy = matrix.getTranslateY() - pendingShapeMatrix.getTranslateY();
+    auto baseBounds = pendingShape->getBounds();
+    auto newBounds = shape->getBounds();
+    auto boundsDx = newBounds.left - baseBounds.left;
+    auto boundsDy = newBounds.top - baseBounds.top;
+    if (boundsDx != 0.0f || boundsDy != 0.0f) {
+      // Map local-space bounds offset to device space through the matrix linear part.
+      dx += matrix.getScaleX() * boundsDx + matrix.getSkewX() * boundsDy;
+      dy += matrix.getSkewY() * boundsDx + matrix.getScaleY() * boundsDy;
+    }
+    pendingShapeOffsets.emplace_back(dx, dy);
+    pendingShapeColors.emplace_back(brush.color);
+    return;
+  }
+  flushPendingOps(PendingOpType::Shape, clip, brush);
+  pendingShape = std::move(shape);
+  pendingShapeMatrix = matrix;
+  pendingShapeOffsets.emplace_back(0.0f, 0.0f);
+  pendingShapeColors.emplace_back(brush.color);
+}
+
+bool OpsCompositor::shouldUseStencilCover(const Brush& brush) const {
+#ifndef TGFX_ENABLE_STENCIL_COVER_PATH
+  // Compile-time master switch: shouldUseStencilCover returns false unconditionally when
+  // TGFX_ENABLE_STENCIL_COVER_PATH is off, which removes the only caller of the stencil-cover
+  // dispatch path (drawStencilCoverPath) and yields zero runtime overhead. The stencil-cover
+  // support files (tessellator, draw op, GPs, upload task) are still pulled in by the CMake
+  // GLOB and rely on the linker's dead-code stripping to drop them from the final binary.
+  USE(brush);
+  return false;
+#else
+  // Any brush requesting antialiasing keeps using the legacy triangulation path so the
+  // existing coverage-AA / alpha-ramp visual contract is preserved without modification.
+  // MSAA render targets are *not* excluded: the stencil pass evaluates the Loop-Blinn test
+  // per-sample when the depth/stencil attachment is multisampled (OpsRenderTask requests the
+  // stencil texture with the same sampleCount as the render target), so hardware MSAA and
+  // stencil-and-cover compose naturally — MSAA handles edge coverage while stencil-and-cover
+  // handles interior/exterior classification.
+  if (brush.antiAlias) {
+    return false;
+  }
+  // Hardware gate: the render path requires a renderable stencil attachment. All other
+  // eligibility checks (this path being the tgfx-side choice for non-AA fills) are encoded
+  // in this method, not in GPUFeatures.
+  return context->gpu()->features()->stencilAttachmentSupported;
+#endif
+}
+
+void OpsCompositor::drawMesh(std::shared_ptr<Mesh> mesh, const Matrix& matrix,
+                             const ClipStack& clip, const Brush& brush) {
+  DEBUG_ASSERT(mesh != nullptr);
+  flushPendingOps();
+
+  auto meshBase = static_cast<MeshBase*>(mesh.get());
+
+  std::optional<Rect> localBounds = std::nullopt;
+  std::optional<Rect> deviceBounds = std::nullopt;
+  auto [needLocalBounds, needDeviceBounds] = needComputeBounds(brush, meshBase->hasCoverage());
+  auto clipBounds = getClipBounds(clip);
+
+  float drawScale = 1.0f;
+  auto meshBounds = mesh->bounds();
+  if (needLocalBounds) {
+    localBounds = ClipLocalBounds(meshBounds, matrix, clipBounds);
+    if (localBounds->isEmpty()) {
+      return;
+    }
+    drawScale = std::min(matrix.getMaxScale(), 1.0f);
+  }
+
+  if (needDeviceBounds) {
+    deviceBounds = matrix.mapRect(meshBounds);
+    if (!deviceBounds->intersect(clipBounds)) {
+      deviceBounds->setEmpty();
+    }
+  }
+
+  // Determine if mesh has vertex colors (only VertexMesh can have these)
+  bool hasColors = false;
+  if (meshBase->type() == MeshBase::Type::Vertex) {
+    auto vertexMesh = static_cast<VertexMesh*>(meshBase);
+    hasColors = vertexMesh->hasColors();
+  }
+
+  // Determine final color based on blending rules (see Canvas.h drawMesh documentation):
+  // Paint color is only used when no shader and no vertex colors; otherwise use white.
+  PMColor gpColor = PMColor::White();
+  if (!brush.shader && !hasColors) {
+    gpColor = ToPMColor(brush.color, dstColorSpace);
+  }
+
+  auto meshProxy = proxyProvider()->createGPUMeshProxy(mesh, renderFlags, dstColorSpace);
+  auto drawOp = MeshDrawOp::Make(std::move(meshProxy), gpColor, matrix);
+  if (drawOp == nullptr) {
+    return;
+  }
+
+  // Handle shader for mesh with special blending rules:
+  // - shader + colors: texture * vertexColor (Modulate)
+  // - shader only: pure texture
+  if (brush.shader) {
+    FPArgs args = {context, renderFlags, localBounds.value_or(Rect::MakeEmpty()), drawScale};
+    auto textureFP = FragmentProcessor::Make(brush.shader, args, nullptr, dstColorSpace);
+    if (textureFP == nullptr) {
+      return;
+    }
+    if (hasColors) {
+      textureFP = XfermodeFragmentProcessor::MakeFromSrcProcessor(
+          drawingAllocator(), std::move(textureFP), BlendMode::Modulate);
+    }
+    drawOp->addColorFP(std::move(textureFP));
+  }
+
+  // Create a brush without shader to pass to addDrawOp, since we handled shader above.
+  Brush meshBrush = brush;
+  meshBrush.shader = nullptr;
+  addDrawOp(std::move(drawOp), clip, meshBrush, localBounds, deviceBounds, drawScale);
+}
+
+void OpsCompositor::drawHairlineShape(std::shared_ptr<Shape> shape, const Matrix& matrix,
+                                      const ClipStack& clip, const Brush& brush,
+                                      const Stroke* stroke) {
+  DEBUG_ASSERT(shape != nullptr);
+  flushPendingOps();
+  Matrix uvMatrix = {};
+  if (!matrix.invert(&uvMatrix)) {
+    return;
+  }
+  std::optional<Rect> localBounds = std::nullopt;
+  std::optional<Rect> deviceBounds = std::nullopt;
+  float drawScale = 1.0f;
+
+  auto [needLocalBounds, needDeviceBounds] = needComputeBounds(brush, true);
+  auto clipBounds = getClipBounds(clip);
+  if (needLocalBounds) {
+    localBounds = shape->getBounds();
+    localBounds = ClipLocalBounds(*localBounds, matrix, clipBounds);
+    drawScale = std::min(matrix.getMaxScale(), 1.0f);
+  }
+  shape = Shape::ApplyMatrix(std::move(shape), matrix);
+  if (!shape) {
+    return;
+  }
+  if (needDeviceBounds) {
+    deviceBounds = shape->getBounds();
+    if (!deviceBounds->intersect(clipBounds)) {
+      deviceBounds->setEmpty();
+    }
+  }
+
+  bool hasCap =
+      stroke != nullptr && (stroke->cap == LineCap::Round || stroke->cap == LineCap::Square);
+  auto aaType = getAAType(brush);
+  auto dstColor = ToPMColor(brush.color, dstColorSpace);
+  auto hairlineProxy = proxyProvider()->createGPUHairlineProxy(shape, hasCap, renderFlags);
+  if (hairlineProxy == nullptr) {
+    return;
+  }
+  auto coverage = GetHairlineAlphaFactor(*stroke, matrix);
+  auto lineDrawOp = HairlineLineOp::Make(hairlineProxy, dstColor, uvMatrix, coverage, aaType);
+  addDrawOp(std::move(lineDrawOp), clip, brush, localBounds, deviceBounds, drawScale);
+  auto quadDrawOp = HairlineQuadOp::Make(hairlineProxy, dstColor, uvMatrix, coverage, aaType);
+  addDrawOp(std::move(quadDrawOp), clip, brush, localBounds, deviceBounds, drawScale);
+}
+
+void OpsCompositor::discardAll() {
+  drawOps.clear();
+  clearColor.reset();
+  if (pendingType != PendingOpType::Unknown) {
+    resetPendingOps();
+  }
+}
+
+void OpsCompositor::resetPendingOps(PendingOpType type, ClipStack clip, Brush brush) {
+  hasRectToRectDraw = false;
+  pendingType = type;
+  pendingClip = std::move(clip);
+  pendingBrush = std::move(brush);
+  pendingImage = nullptr;
+  pendingSampling = {};
+  pendingConstraint = SrcRectConstraint::Fast;
+  pendingRects.clear();
+  pendingUVRects.clear();
+  pendingSubsetRects.clear();
+  pendingRRects.clear();
+  pendingStrokes.clear();
+  pendingAtlasTexture = nullptr;
+  pendingShape = nullptr;
+  pendingShapeMatrix = {};
+  pendingShapeOffsets.clear();
+  pendingShapeColors.clear();
+  pendingStencilCoverShapes.clear();
+  pendingStencilCoverMatrices.clear();
+  pendingStencilCoverColors.clear();
+}
+
+bool OpsCompositor::CompareBrush(const Brush& a, const Brush& b) {
+  // Ignore the color differences.
+  if (a.antiAlias != b.antiAlias || a.blendMode != b.blendMode) {
+    return false;
+  }
+  if (a.shader != b.shader) {
+    if (!a.shader || !b.shader || !a.shader->isEqual(b.shader.get())) {
+      return false;
+    }
+  }
+  if (a.maskFilter != b.maskFilter) {
+    if (!a.maskFilter || !b.maskFilter || !a.maskFilter->isEqual(b.maskFilter.get())) {
+      return false;
+    }
+  }
+  if (a.colorFilter != b.colorFilter) {
+    if (!a.colorFilter || !b.colorFilter || !a.colorFilter->isEqual(b.colorFilter.get())) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool OpsCompositor::canAppend(PendingOpType type, const ClipStack& clip, const Brush& brush) const {
+  if (pendingType != type || !pendingClip.isSame(clip) || !CompareBrush(pendingBrush, brush)) {
+    return false;
+  }
+  switch (pendingType) {
+    case PendingOpType::Rect:
+    case PendingOpType::Image:
+    case PendingOpType::Atlas:
+      return pendingRects.size() < RectDrawOp::MaxNumRects;
+    case PendingOpType::RRect:
+      return pendingRRects.size() < RRectDrawOp::MaxNumRRects;
+    case PendingOpType::Shape:
+      return pendingShapeOffsets.size() < ShapeInstancedDrawOp::MaxNumInstances;
+    case PendingOpType::StencilCoverPath:
+      return pendingStencilCoverShapes.size() < StencilCoverPathDrawOp::MaxNumBatched;
+    default:
+      break;
+  }
+  return true;
+}
+
+class PendingOpsAutoReset {
+ public:
+  PendingOpsAutoReset(OpsCompositor* compositor, PendingOpType type, ClipStack clip, Brush brush)
+      : compositor(compositor), type(type), clip(std::move(clip)), brush(std::move(brush)) {
+  }
+
+  ~PendingOpsAutoReset() {
+    compositor->resetPendingOps(type, std::move(clip), std::move(brush));
+  }
+
+ private:
+  OpsCompositor* compositor;
+  PendingOpType type;
+  ClipStack clip;
+  Brush brush;
+};
+
+void OpsCompositor::flushPendingOps(PendingOpType type, ClipStack clip, Brush brush) {
+  if (pendingType == PendingOpType::Unknown) {
+    if (type != PendingOpType::Unknown) {
+      pendingType = type;
+      pendingClip = std::move(clip);
+      pendingBrush = std::move(brush);
+    }
+    return;
+  }
+  PendingOpsAutoReset autoReset(this, type, std::move(clip), std::move(brush));
+  // Shape is handled separately with its own bounds computation.
+  if (pendingType == PendingOpType::Shape) {
+    flushPendingShapeOps();
+    return;
+  }
+  if (pendingType == PendingOpType::StencilCoverPath) {
+    flushPendingStencilCoverOps();
+    return;
+  }
+  PlacementPtr<DrawOp> drawOp = nullptr;
+  std::optional<Rect> localBounds = std::nullopt;
+  std::optional<Rect> deviceBounds = std::nullopt;
+  std::optional<float> drawScale = std::nullopt;
+  // Conservative prediction of whether the final DrawOp will have coverage. This determines if
+  // deviceBounds needs to be computed for DstTexture creation. We assume coverage exists unless
+  // clip is empty, since some ops (e.g., AtlasTextOp) always have coverage regardless of clip.
+  // Underestimating causes draws to be skipped on GPUs without frameBufferFetch (e.g., SwiftShader).
+  bool hasCoverage = pendingBrush.maskFilter != nullptr || pendingClip.state() != ClipState::Empty;
+  bool hasImageFill = pendingType == PendingOpType::Image;
+  auto [needLocalBounds, needDeviceBounds] =
+      needComputeBounds(pendingBrush, hasCoverage, hasImageFill);
+  auto aaType = getAAType(pendingBrush);
+  Rect clipBounds = {};
+  if (needLocalBounds || needDeviceBounds) {
+    clipBounds = getClipBounds(pendingClip);
+  }
+  if (needLocalBounds) {
+    localBounds = Rect::MakeEmpty();
+    drawScale = 0.0f;
+  }
+
+  if (needLocalBounds || needDeviceBounds) {
+    if (pendingType == PendingOpType::RRect) {
+      deviceBounds = Rect::MakeEmpty();
+      for (auto& record : pendingRRects) {
+        auto rect = record->viewMatrix.mapRect(record->rRect.rect());
+        deviceBounds->join(rect);
+        drawScale = std::max(*drawScale, record->viewMatrix.getMaxScale());
+      }
+      if (!deviceBounds->intersect(clipBounds)) {
+        deviceBounds->setEmpty();
+      }
+      localBounds = deviceBounds;
+      if (!localBounds->intersect(clipBounds)) {
+        localBounds->setEmpty();
+      }
+    } else {
+      if (needLocalBounds) {
+        auto rectCount = pendingRects.size();
+        for (size_t i = 0; i < rectCount; i++) {
+          auto& record = pendingRects[i];
+          auto viewMatrix = record->viewMatrix;
+          auto rect = &record->rect;
+          if (hasRectToRectDraw) {
+            auto& uvRect = *pendingUVRects[i];
+            viewMatrix.preConcat(MakeRectToRectMatrix(uvRect, record->rect));
+            rect = &uvRect;
+          }
+          localBounds->join(ClipLocalBounds(*rect, viewMatrix, clipBounds));
+          drawScale = std::max(*drawScale, viewMatrix.getMaxScale());
+        }
+      }
+      if (needDeviceBounds) {
+        deviceBounds = Rect::MakeEmpty();
+        for (auto& record : pendingRects) {
+          auto rect = record->viewMatrix.mapRect(record->rect);
+          deviceBounds->join(rect);
+        }
+        if (!deviceBounds->intersect(clipBounds)) {
+          deviceBounds->setEmpty();
+        }
+      }
+    }
+    if (localBounds.has_value() && localBounds->isEmpty()) {
+      return;
+    }
+  }
+
+  switch (pendingType) {
+    case PendingOpType::Rect:
+      if (pendingRects.size() == 1 && pendingStrokes.empty()) {
+        auto& paint = pendingRects.front();
+        if (drawAsClear(paint->rect, paint->viewMatrix, pendingClip, pendingBrush)) {
+          return;
+        }
+      }
+    // fallthrough
+    case PendingOpType::Image: {
+      auto subsetMode = UVSubsetMode::None;
+      if (pendingConstraint == SrcRectConstraint::Strict && pendingImage) {
+        subsetMode = pendingSampling.magFilterMode == FilterMode::Linear ||
+                             pendingSampling.minFilterMode == FilterMode::Linear
+                         ? UVSubsetMode::SubsetOnly
+                         : UVSubsetMode::RoundOutAndSubset;
+      }
+      bool needUVCoord =
+          needLocalBounds && (hasRectToRectDraw || HasDifferentViewMatrix(pendingRects));
+      auto uvRects =
+          hasRectToRectDraw ? std::move(pendingUVRects) : std::vector<PlacementPtr<Rect>>();
+      // pendingSubsetRects is populated only when constraint == Strict (per fillImageRect).
+      // When subsetMode != None we must provide subset rects of the same size as pendingRects.
+      auto subsetRects = std::move(pendingSubsetRects);
+      auto provider = RectsVertexProvider::MakeFrom(
+          drawingAllocator(), std::move(pendingRects), std::move(uvRects), std::move(subsetRects),
+          aaType, needUVCoord, subsetMode, std::move(pendingStrokes), dstColorSpace);
+      drawOp = RectDrawOp::Make(context, std::move(provider), renderFlags);
+    } break;
+    case PendingOpType::RRect: {
+      auto provider =
+          RRectsVertexProvider::MakeFrom(drawingAllocator(), std::move(pendingRRects), aaType,
+                                         std::move(pendingStrokes), dstColorSpace);
+      drawOp = RRectDrawOp::Make(context, std::move(provider), renderFlags);
+    } break;
+    case PendingOpType::Atlas: {
+      auto provider =
+          RectsVertexProvider::MakeFrom(drawingAllocator(), std::move(pendingRects), {}, {},
+                                        AAType::None, true, UVSubsetMode::None, {}, dstColorSpace);
+      drawOp = AtlasTextOp::Make(context, std::move(provider), renderFlags,
+                                 std::move(pendingAtlasTexture), pendingSampling);
+    } break;
+    default:
+      break;
+  }
+  if (drawOp != nullptr && pendingType == PendingOpType::Image) {
+    FPArgs args = {context, renderFlags, localBounds.value_or(Rect::MakeEmpty()),
+                   drawScale.value_or(1.0f)};
+    auto processor =
+        FragmentProcessor::Make(pendingImage, args, pendingSampling, pendingConstraint);
+    if (processor == nullptr) {
+      return;
+    }
+    drawOp->addColorFP(std::move(processor));
+    if (!pendingImage->isAlphaOnly() &&
+        NeedConvertColorSpace(pendingImage->colorSpace(), dstColorSpace)) {
+      auto xformEffect = ColorSpaceXformEffect::Make(
+          context->drawingAllocator(), pendingImage->colorSpace().get(), AlphaType::Premultiplied,
+          dstColorSpace.get(), AlphaType::Premultiplied);
+      drawOp->addColorFP(std::move(xformEffect));
+    }
+  }
+  addDrawOp(std::move(drawOp), pendingClip, pendingBrush, localBounds, deviceBounds,
+            drawScale.value_or(1.0f));
+}
+
+void OpsCompositor::flushPendingShapeOps() {
+  DEBUG_ASSERT(pendingShape != nullptr);
+  DEBUG_ASSERT(!pendingShapeOffsets.empty());
+  auto shape = std::move(pendingShape);
+  auto shapeMatrix = pendingShapeMatrix;
+  auto offsets = std::move(pendingShapeOffsets);
+  auto shapeColors = std::move(pendingShapeColors);
+
+  Matrix uvMatrix = {};
+  if (!shapeMatrix.invert(&uvMatrix)) {
+    return;
+  }
+
+  auto clipBounds = getClipBounds(pendingClip);
+  auto count = offsets.size();
+  std::optional<Rect> localBounds = std::nullopt;
+  std::optional<Rect> deviceBounds = std::nullopt;
+  float drawScale = 1.0f;
+  auto [needLocalBounds, needDeviceBounds] = needComputeBounds(pendingBrush, true);
+
+  // Compute the union of all instance bounds in the first instance's local space.
+  // offsets are in device space, so convert them to local space using uvMatrix (inverse of
+  // shapeMatrix) before offsetting shape bounds.
+  Rect shapeBounds = {};
+  if ((needLocalBounds || needDeviceBounds) && !shape->isInverseFillType()) {
+    const auto baseBounds = shape->getBounds();
+    for (size_t i = 0; i < count; ++i) {
+      auto localX = uvMatrix.getScaleX() * offsets[i].x + uvMatrix.getSkewX() * offsets[i].y;
+      auto localY = uvMatrix.getSkewY() * offsets[i].x + uvMatrix.getScaleY() * offsets[i].y;
+      shapeBounds.join(baseBounds.makeOffset(localX, localY));
+    }
+  }
+  if (needLocalBounds) {
+    if (shape->isInverseFillType()) {
+      localBounds = ToLocalBounds(clipBounds, shapeMatrix);
+    } else {
+      localBounds = ClipLocalBounds(shapeBounds, shapeMatrix, clipBounds);
+    }
+    if (localBounds->isEmpty()) {
+      return;
+    }
+    drawScale = std::min(shapeMatrix.getMaxScale(), 1.0f);
+  }
+  if (needDeviceBounds) {
+    deviceBounds = shape->isInverseFillType() ? clipBounds : shapeMatrix.mapRect(shapeBounds);
+    if (!shape->isInverseFillType() && !deviceBounds->intersect(clipBounds)) {
+      deviceBounds->setEmpty();
+    }
+  }
+
+  shape = Shape::ApplyMatrix(std::move(shape), shapeMatrix);
+  if (!shape) {
+    return;
+  }
+
+  auto aaType = getAAType(pendingBrush);
+  auto shapeProxy = proxyProvider()->createGPUShapeProxy(shape, aaType, clipBounds, renderFlags);
+
+  if (count == 1) {
+    auto dstColor = ToPMColor(pendingBrush.color, dstColorSpace);
+    auto drawOp = ShapeDrawOp::Make(std::move(shapeProxy), dstColor, uvMatrix, aaType);
+    addDrawOp(std::move(drawOp), pendingClip, pendingBrush, localBounds, deviceBounds, drawScale);
+  } else {
+    const Color* colorsPtr = pendingBrush.shader ? nullptr : shapeColors.data();
+    auto drawOp = ShapeInstancedDrawOp::Make(std::move(shapeProxy), offsets.data(), colorsPtr,
+                                             count, uvMatrix, shapeMatrix, aaType, dstColorSpace);
+    addDrawOp(std::move(drawOp), pendingClip, pendingBrush, localBounds, deviceBounds, drawScale);
+  }
+}
+
+void OpsCompositor::flushPendingStencilCoverOps() {
+  DEBUG_ASSERT(!pendingStencilCoverShapes.empty());
+  DEBUG_ASSERT(pendingStencilCoverShapes.size() == pendingStencilCoverMatrices.size());
+  DEBUG_ASSERT(pendingStencilCoverShapes.size() == pendingStencilCoverColors.size());
+  auto shapes = std::move(pendingStencilCoverShapes);
+  auto matrices = std::move(pendingStencilCoverMatrices);
+  auto colors = std::move(pendingStencilCoverColors);
+  auto count = shapes.size();
+
+  auto [needLocalBounds, needDeviceBounds] = needComputeBounds(pendingBrush, /*hasCoverage=*/true);
+  auto clipBounds = getClipBounds(pendingClip);
+
+  for (size_t i = 0; i < count; ++i) {
+    const auto& shape = shapes[i];
+    const auto& matrix = matrices[i];
+    const auto& color = colors[i];
+
+    auto geometryProxy = proxyProvider()->createStencilCoverPathProxy(shape, renderFlags);
+    if (geometryProxy == nullptr) {
+      continue;
+    }
+
+    auto shapeBounds = shape->getBounds();
+    bool isInverseFill = shape->isInverseFillType();
+    if (isInverseFill && clipBounds.isEmpty()) {
+      continue;
+    }
+    // Local-space clip rect is used by both the inverse-fill local bounds and the cover
+    // quad. A non-invertible view matrix is a hard error for this op — bail out before
+    // consuming any further resources.
+    Matrix uvMatrix = {};
+    if (!matrix.invert(&uvMatrix)) {
+      continue;
+    }
+    Rect localClipBounds = uvMatrix.mapRect(clipBounds);
+
+    std::optional<Rect> localBounds = std::nullopt;
+    std::optional<Rect> deviceBounds = std::nullopt;
+    float drawScale = 1.0f;
+    if (needLocalBounds) {
+      if (isInverseFill) {
+        localBounds = localClipBounds;
+      } else {
+        localBounds = ClipLocalBounds(shapeBounds, matrix, clipBounds);
+        if (localBounds->isEmpty()) {
+          continue;
+        }
+      }
+      drawScale = std::min(matrix.getMaxScale(), 1.0f);
+    }
+    if (needDeviceBounds) {
+      if (isInverseFill) {
+        deviceBounds = clipBounds;
+      } else {
+        deviceBounds = matrix.mapRect(shapeBounds);
+        if (!deviceBounds->intersect(clipBounds)) {
+          deviceBounds->setEmpty();
+        }
+      }
+    }
+
+    Rect coverLocalBounds = isInverseFill ? localClipBounds : shapeBounds;
+    if (coverLocalBounds.isEmpty()) {
+      continue;
+    }
+
+    auto dstColor = ToPMColor(color, dstColorSpace);
+    auto fillType = shape->fillType();
+    auto drawOp = StencilCoverPathDrawOp::Make(std::move(geometryProxy), dstColor, matrix,
+                                               coverLocalBounds, fillType);
+    if (drawOp == nullptr) {
+      continue;
+    }
+    addDrawOp(std::move(drawOp), pendingClip, pendingBrush, localBounds, deviceBounds, drawScale);
+  }
+}
+
+static void FlipYIfNeeded(Rect* rect, const RenderTargetProxy* renderTarget) {
+  if (renderTarget->origin() == ImageOrigin::BottomLeft) {
+    renderTarget->getOriginTransform().mapRect(rect);
+  }
+}
+
+static bool HasColorOnly(const Brush& brush) {
+  return !brush.shader && !brush.maskFilter && !brush.colorFilter;
+}
+
+bool OpsCompositor::drawAsClear(const Rect& rect, const Matrix& matrix, const ClipStack& clip,
+                                const Brush& brush) {
+  if (!HasColorOnly(brush) || !brush.isOpaque() || !matrix.rectStaysRect()) {
+    return false;
+  }
+  auto deviceBounds = renderTarget->bounds();
+  Rect clipRect = {};
+  switch (clip.state()) {
+    case ClipState::WideOpen:
+      clipRect = deviceBounds;
+      break;
+    case ClipState::Rect:
+      clipRect = clip.bounds();
+      break;
+    case ClipState::Empty:
+    case ClipState::Complex:
+      return false;
+  }
+  auto bounds = rect;
+  matrix.mapRect(&bounds);
+  if (!bounds.intersect(clipRect) || !IsClipPixelAligned(bounds)) {
+    return false;
+  }
+  bounds.round();
+  if (bounds != deviceBounds) {
+    return false;
+  }
+  // discard all previous ops since the clear rect covers the entire render target.
+  drawOps.clear();
+  auto format = renderTarget->format();
+  auto writeSwizzle = Swizzle::ForWrite(format);
+  auto dstColor = ToPMColor(brush.color, dstColorSpace);
+  clearColor = writeSwizzle.applyTo(dstColor);
+  return true;
+}
+
+void OpsCompositor::makeClosed() {
+  if (renderTarget == nullptr) {
+    return;
+  }
+  flushPendingOps();
+  submitDrawOps();
+  renderTarget = nullptr;
+  // Remove the compositor from the list, so it won't be flushed again.
+  context->drawingManager()->compositors.erase(cachedPosition);
+}
+
+AAType OpsCompositor::getAAType(const Brush& brush) const {
+  return getAAType(brush.antiAlias);
+}
+
+AAType OpsCompositor::getAAType(bool antiAlias) const {
+  if (renderTarget->sampleCount() > 1) {
+    return AAType::MSAA;
+  }
+  if (antiAlias) {
+    return AAType::Coverage;
+  }
+  return AAType::None;
+}
+
+std::pair<bool, bool> OpsCompositor::needComputeBounds(const Brush& brush, bool hasCoverage,
+                                                       bool hasImageFill) {
+  bool needLocalBounds = hasImageFill || brush.shader != nullptr || brush.maskFilter != nullptr;
+  bool needDeviceBounds = false;
+  if (BlendModeNeedDstTexture(brush.blendMode, hasCoverage)) {
+    auto shaderCaps = context->shaderCaps();
+    auto features = context->gpu()->features();
+    if (!shaderCaps->frameBufferFetchSupport &&
+        (!features->textureBarrier || renderTarget->asTextureProxy() == nullptr ||
+         renderTarget->sampleCount() > 1)) {
+      needDeviceBounds = true;
+    }
+  }
+  if (pendingType == PendingOpType::RRect && (needDeviceBounds || needLocalBounds)) {
+    // When either localBounds or deviceBounds needs to be computed for RRect, both should be set to
+    // true, since localBounds and deviceBounds are computed together in that case.
+    needLocalBounds = true;
+    needDeviceBounds = true;
+  }
+  return {needLocalBounds, needDeviceBounds};
+}
+
+Rect OpsCompositor::getClipBounds(const ClipStack& clip) const {
+  if (clip.state() == ClipState::WideOpen) {
+    return renderTarget->bounds();
+  }
+  auto bounds = clip.bounds();
+  if (!bounds.intersect(renderTarget->bounds())) {
+    bounds.setEmpty();
+  }
+  return bounds;
+}
+
+AppliedClip OpsCompositor::applyClip(const ClipStack& clipStack) {
+  AppliedClip out;
+
+  // Stage 1: Fast path for Empty and WideOpen states.
+  if (clipStack.state() == ClipState::Empty) {
+    out.status = AppliedClipStatus::ClippedOut;
+    return out;
+  }
+  if (clipStack.state() == ClipState::WideOpen) {
+    out.status = AppliedClipStatus::Unclipped;
+    return out;
+  }
+
+  // Stage 2: Set initial scissor from clip bounds to restrict drawing area.
+  auto clipBounds = clipStack.bounds();
+  if (!clipBounds.intersect(renderTarget->bounds())) {
+    out.status = AppliedClipStatus::ClippedOut;
+    return out;
+  }
+  clipBounds.roundOut();
+  auto scissorBounds = clipBounds;
+  FlipYIfNeeded(&scissorBounds, renderTarget.get());
+  out.scissor = scissorBounds;
+
+  // Stage 3: Iterate through valid elements.
+  auto& elements = clipStack.elements();
+  std::vector<const ClipElement*> elementsForMask;
+  elementsForMask.reserve(elements.size() - clipStack.oldestValidIndex());
+  PlacementPtr<FragmentProcessor> clipFP = nullptr;
+  // Limit the analytic FP chain length; longer chains bloat program keys and shader complexity.
+  // Excess elements fall through to the mask path.
+  constexpr size_t MaxAnalyticFPs = 4;
+  size_t analyticFPCount = 0;
+  for (size_t i = clipStack.oldestValidIndex(); i < elements.size(); ++i) {
+    auto& element = elements[i];
+    if (!element.isValid()) {
+      continue;
+    }
+
+    // Inner and outer bounds coincide only for an axis-aligned rect whose device footprint is an
+    // exact integer pixel box: any non-AA rect (snapped to the grid) or a pixel-aligned AA rect.
+    // Such an element is exactly an integer scissor rect already covered by the clipBounds scissor,
+    // so it needs no coverage FP or mask.
+    if (element.innerBounds() == element.outerBounds()) {
+      continue;
+    }
+
+    // Prefer the analytic FP path: it evaluates coverage in the shader and avoids the extra
+    // texture allocation and render pass of the mask path.
+    if (analyticFPCount < MaxAnalyticFPs) {
+      auto [success, result] = tryApplyAnalyticFP(element, std::move(clipFP));
+      clipFP = std::move(result);
+      if (success) {
+        ++analyticFPCount;
+        continue;
+      }
+    }
+
+    // Collect elements that need mask processing.
+    elementsForMask.push_back(&element);
+  }
+
+  // Stage 4: Generate mask for remaining elements
+  if (!elementsForMask.empty()) {
+    clipFP = getClipMaskFP(elementsForMask, clipStack.uniqueID(), clipBounds, std::move(clipFP));
+  }
+
+  out.coverageFP = std::move(clipFP);
+  out.status = AppliedClipStatus::Clipped;
+  return out;
+}
+
+std::pair<bool, PlacementPtr<FragmentProcessor>> OpsCompositor::tryApplyAnalyticFP(
+    const ClipElement& element, PlacementPtr<FragmentProcessor> inputFP) const {
+  // The shader reads gl_FragCoord in window space, so append the render-target-to-window-space
+  // transform to the element's matrix.
+  auto matrix = element.matrix();
+  matrix.postConcat(renderTarget->getOriginTransform());
+  PlacementPtr<FragmentProcessor> elementFP = nullptr;
+  // Analytic FPs need a linear device-to-local inverse to reconstruct local coordinates in the
+  // shader, which a perspective matrix cannot provide; such elements fall through to the mask path.
+  if (!matrix.hasPerspective()) {
+    const bool aa = element.antiAlias();
+    const auto& shape = element.shape();
+    switch (shape.type()) {
+      case GeometryShape::Type::Rect:
+        elementFP = RectEffect::Make(drawingAllocator(), shape.rect(), matrix, aa);
+        break;
+      case GeometryShape::Type::RRect: {
+        const auto& rRect = shape.rRect();
+        if (rRect.type() == RRect::Type::Rect) {
+          elementFP = RectEffect::Make(drawingAllocator(), rRect.rect(), matrix, aa);
+        } else {
+          elementFP = RRectEffect::Make(drawingAllocator(), rRect, matrix, aa);
+        }
+        break;
+      }
+      case GeometryShape::Type::Empty:
+      case GeometryShape::Type::Path:
+        break;
+    }
+  }
+  // No analytic FP for this element (perspective, empty, or path); return the accumulated chain
+  // unchanged and report failure.
+  if (!elementFP) {
+    return {false, std::move(inputFP)};
+  }
+  if (inputFP) {
+    elementFP =
+        FragmentProcessor::Compose(drawingAllocator(), std::move(inputFP), std::move(elementFP));
+  }
+  return {true, std::move(elementFP)};
+}
+
+PlacementPtr<FragmentProcessor> OpsCompositor::getClipMaskFP(
+    const std::vector<const ClipElement*>& elements, uint32_t uniqueID, const Rect& clipBound,
+    PlacementPtr<FragmentProcessor> inputFP) {
+  // OpsCompositor is bound to a single RenderTarget, so using uniqueID alone as the cache key
+  // (without clipBound) is safe.
+  if (uniqueID == cachedClipID && clipTexture) {
+    return makeMaskFP(clipTexture, clipBound, std::move(inputFP));
+  }
+  clipTexture = makeClipTexture(elements, clipBound);
+  if (clipTexture == nullptr) {
+    DEBUG_ASSERT(false);
+    return inputFP;
+  }
+  cachedClipID = uniqueID;
+  return makeMaskFP(clipTexture, clipBound, std::move(inputFP));
+}
+
+std::shared_ptr<TextureProxy> OpsCompositor::makeClipTexture(
+    const std::vector<const ClipElement*>& elements, const Rect& bounds) const {
+  const auto width = FloatSaturateToInt(bounds.width());
+  const auto height = FloatSaturateToInt(bounds.height());
+  const auto rasterizeMatrix = Matrix::MakeTrans(-bounds.left, -bounds.top);
+  auto clipRenderTarget = RenderTargetProxy::Make(context, width, height, true, 1, false,
+                                                  ImageOrigin::TopLeft, BackingFit::Approx);
+  if (clipRenderTarget == nullptr) {
+    DEBUG_ASSERT(false);
+    return nullptr;
+  }
+
+  std::vector<PlacementPtr<DrawOp>> clipDrawOps;
+  clipDrawOps.reserve(elements.size());
+  for (size_t i = 0; i < elements.size(); ++i) {
+    const auto element = elements[i];
+    DEBUG_ASSERT(element->isValid());
+    const auto aaType = element->antiAlias() ? AAType::Coverage : AAType::None;
+    auto clipBounds = Rect::MakeWH(width, height);
+    auto path = element->getDevicePath();
+    if (i > 0) {
+      // Modulate blend erases the mask when hasCoverage is true (source coefficient becomes zero).
+      // Use inverse fill + DstOut to erase areas outside each clip shape instead.
+      path.toggleInverseFillType();
+    }
+    auto shape = Shape::MakeFrom(path);
+    shape = Shape::ApplyMatrix(std::move(shape), rasterizeMatrix);
+    auto shapeProxy = proxyProvider()->createGPUShapeProxy(shape, aaType, clipBounds, renderFlags);
+    auto uvMatrix = Matrix::MakeTrans(bounds.left, bounds.top);
+    auto drawOp = ShapeDrawOp::Make(std::move(shapeProxy), {}, uvMatrix, aaType);
+    if (i > 0) {
+      drawOp->setBlendMode(BlendMode::DstOut);
+    }
+    clipDrawOps.emplace_back(std::move(drawOp));
+  }
+
+  auto opArray = drawingAllocator()->makeArray(std::move(clipDrawOps));
+  auto textureProxy = clipRenderTarget->asTextureProxy();
+  context->drawingManager()->addOpsRenderTask(std::move(clipRenderTarget), std::move(opArray),
+                                              PMColor::Transparent());
+  return textureProxy;
+}
+
+PlacementPtr<FragmentProcessor> OpsCompositor::makeMaskFP(
+    std::shared_ptr<TextureProxy> maskTexture, const Rect& bounds,
+    PlacementPtr<FragmentProcessor> inputFP) const {
+  const auto allocator = drawingAllocator();
+  auto uvMatrix = Matrix::MakeTrans(-bounds.left, -bounds.top);
+  if (renderTarget->origin() == ImageOrigin::BottomLeft) {
+    uvMatrix.preConcat(renderTarget->getOriginTransform());
+  }
+  PlacementPtr<FragmentProcessor> maskFP =
+      DeviceSpaceTextureEffect::Make(allocator, std::move(maskTexture), uvMatrix);
+  maskFP = FragmentProcessor::MulInputByChildAlpha(allocator, std::move(maskFP));
+  if (!inputFP) {
+    return maskFP;
+  }
+  return FragmentProcessor::Compose(allocator, std::move(maskFP), std::move(inputFP));
+}
+
+DstTextureInfo OpsCompositor::makeDstTextureInfo(const Rect& deviceBounds, AAType aaType) {
+  if (context->shaderCaps()->frameBufferFetchSupport) {
+    return {};
+  }
+  Rect bounds = {};
+  auto features = context->gpu()->features();
+  auto textureProxy = features->textureBarrier ? renderTarget->asTextureProxy() : nullptr;
+  if (textureProxy == nullptr || renderTarget->sampleCount() > 1) {
+    if (deviceBounds.isEmpty()) {
+      return {};
+    }
+    bounds = deviceBounds;
+    if (aaType != AAType::None) {
+      bounds.outset(1.0f, 1.0f);
+    }
+    bounds.roundOut();
+    if (!bounds.intersect(renderTarget->bounds())) {
+      return {};
+    }
+    FlipYIfNeeded(&bounds, renderTarget.get());
+  }
+  DstTextureInfo dstTextureInfo = {};
+  if (textureProxy != nullptr) {
+    if (renderTarget->sampleCount() > 1) {
+      // Submit draw ops immediately to ensure the MSAA render target is resolved.
+      submitDrawOps();
+    }
+    dstTextureInfo.textureProxy = std::move(textureProxy);
+    return dstTextureInfo;
+  }
+  submitDrawOps();
+  dstTextureInfo.offset = {bounds.x(), bounds.y()};
+  textureProxy = proxyProvider()->createTextureProxy(
+      {}, static_cast<int>(bounds.width()), static_cast<int>(bounds.height()),
+      renderTarget->format(), false, renderTarget->origin(), BackingFit::Approx);
+  if (textureProxy == nullptr) {
+    return {};
+  }
+  context->drawingManager()->addRenderTargetCopyTask(
+      renderTarget, textureProxy, static_cast<int>(bounds.x()), static_cast<int>(bounds.y()));
+  dstTextureInfo.textureProxy = std::move(textureProxy);
+  return dstTextureInfo;
+}
+
+void OpsCompositor::addDrawOp(PlacementPtr<DrawOp> op, const ClipStack& clip, const Brush& brush,
+                              const std::optional<Rect>& localBounds,
+                              const std::optional<Rect>& deviceBounds, float drawScale) {
+
+  if (op == nullptr || brush.nothingToDraw()) {
+    return;
+  }
+  DEBUG_ASSERT(renderTarget != nullptr);
+  if (localBounds.has_value() && localBounds->isEmpty()) {
+    return;
+  }
+  auto appliedClip = applyClip(clip);
+  if (appliedClip.status == AppliedClipStatus::ClippedOut) {
+    return;
+  }
+
+  FPArgs args = {context, renderFlags, localBounds.value_or(Rect::MakeEmpty()), drawScale};
+  auto colorFilter = brush.colorFilter;
+  if (brush.shader) {
+    auto shader = brush.shader;
+    // If the color filter transforms transparent pixels into non-transparent ones, merge it with
+    // the shader so that the original shader alpha masks the color filter output.
+    if (colorFilter && colorFilter->affectsTransparentBlack()) {
+      shader = shader->makeWithColorFilter(colorFilter);
+      colorFilter = nullptr;
+    }
+    if (auto processor = FragmentProcessor::Make(shader, args, nullptr, dstColorSpace)) {
+      op->addColorFP(std::move(processor));
+    } else {
+      // The shader is the main source of color, so if it fails to create a processor, we can't
+      // draw anything.
+      return;
+    }
+  }
+  if (colorFilter) {
+    if (auto processor = colorFilter->asFragmentProcessor(context, dstColorSpace)) {
+      op->addColorFP(std::move(processor));
+    }
+  }
+  if (brush.maskFilter) {
+    if (auto processor = brush.maskFilter->asFragmentProcessor(args, nullptr)) {
+      op->addCoverageFP(std::move(processor));
+    } else {
+      // if mask is empty, nothing to draw
+      return;
+    }
+  }
+
+  if (appliedClip.coverageFP) {
+    op->addCoverageFP(std::move(appliedClip.coverageFP));
+  }
+  if (appliedClip.scissor.has_value()) {
+    op->setScissorRect(*appliedClip.scissor);
+  }
+  op->setBlendMode(brush.blendMode);
+  auto aaType = getAAType(brush);
+  if (BlendModeNeedDstTexture(brush.blendMode, op->hasCoverage())) {
+    auto dstTextureInfo = makeDstTextureInfo(deviceBounds.value_or(Rect::MakeEmpty()), aaType);
+    auto shaderCaps = context->shaderCaps();
+    if (!shaderCaps->frameBufferFetchSupport && dstTextureInfo.textureProxy == nullptr) {
+      return;
+    }
+    auto xferProcessor = PorterDuffXferProcessor::Make(drawingAllocator(), brush.blendMode,
+                                                       std::move(dstTextureInfo));
+    op->setXferProcessor(std::move(xferProcessor));
+  }
+  drawOps.emplace_back(std::move(op));
+}
+
+void OpsCompositor::fillTextAtlas(std::shared_ptr<TextureProxy> textureProxy, const Rect& rect,
+                                  const SamplingOptions& sampling, const Matrix& matrix,
+                                  const ClipStack& clip, const Brush& brush) {
+  DEBUG_ASSERT(textureProxy != nullptr);
+  DEBUG_ASSERT(!rect.isEmpty());
+  if (!canAppend(PendingOpType::Atlas, clip, brush) || pendingAtlasTexture != textureProxy ||
+      pendingSampling != sampling) {
+    flushPendingOps(PendingOpType::Atlas, clip, brush);
+    pendingAtlasTexture = std::move(textureProxy);
+    pendingSampling = sampling;
+  }
+  auto record = drawingAllocator()->make<RectRecord>(rect, matrix, brush.color);
+  pendingRects.emplace_back(std::move(record));
+}
+
+void OpsCompositor::submitDrawOps() {
+  auto opArray = drawingAllocator()->makeArray(std::move(drawOps));
+  context->drawingManager()->addOpsRenderTask(renderTarget, std::move(opArray), clearColor);
+  clearColor.reset();
+}
+
+}  // namespace tgfx