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

package/cpp/third_party/tgfx/src/gpu/ops/StencilCoverPathDrawOp.cpp

@@ -0,0 +1,302 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 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 "StencilCoverPathDrawOp.h"
+#include <algorithm>
+#include <cmath>
+#include "core/utils/Log.h"
+#include "gpu/Program.h"
+#include "gpu/ProgramInfo.h"
+#include "gpu/ProxyProvider.h"
+#include "gpu/RectsVertexProvider.h"
+#include "gpu/processors/StencilCoverCoverPassGeometryProcessor.h"
+#include "gpu/processors/StencilCoverStencilPassGeometryProcessor.h"
+#include "tgfx/core/RenderFlags.h"
+
+namespace tgfx {
+
+// Bytes per stencil-pass vertex: position (Float2) + klm (Float3) = 5 floats.
+static constexpr size_t STENCIL_VERTEX_STRIDE = 5 * sizeof(float);
+
+namespace {
+
+bool IsEvenOdd(PathFillType fillType) {
+  return fillType == PathFillType::EvenOdd || fillType == PathFillType::InverseEvenOdd;
+}
+
+bool IsInverse(PathFillType fillType) {
+  return fillType == PathFillType::InverseWinding || fillType == PathFillType::InverseEvenOdd;
+}
+
+DepthStencilDescriptor MakeStencilPassDS(PathFillType fillType) {
+  DepthStencilDescriptor ds = {};
+  ds.format = PixelFormat::DEPTH24_STENCIL8;
+  ds.depthCompare = CompareFunction::Always;
+  ds.depthWriteEnabled = false;
+  ds.stencilReadMask = 0xFF;
+  ds.stencilWriteMask = 0xFF;
+  if (IsEvenOdd(fillType)) {
+    StencilDescriptor s = {};
+    s.compare = CompareFunction::Always;
+    s.passOp = StencilOperation::Invert;
+    s.failOp = StencilOperation::Keep;
+    s.depthFailOp = StencilOperation::Keep;
+    ds.stencilFront = s;
+    ds.stencilBack = s;
+  } else {
+    StencilDescriptor sf = {};
+    sf.compare = CompareFunction::Always;
+    sf.passOp = StencilOperation::IncrementWrap;
+    sf.failOp = StencilOperation::Keep;
+    sf.depthFailOp = StencilOperation::Keep;
+    ds.stencilFront = sf;
+    StencilDescriptor sb = {};
+    sb.compare = CompareFunction::Always;
+    sb.passOp = StencilOperation::DecrementWrap;
+    sb.failOp = StencilOperation::Keep;
+    sb.depthFailOp = StencilOperation::Keep;
+    ds.stencilBack = sb;
+  }
+  return ds;
+}
+
+DepthStencilDescriptor MakeCoverPassDS(PathFillType fillType) {
+  DepthStencilDescriptor ds = {};
+  ds.format = PixelFormat::DEPTH24_STENCIL8;
+  ds.depthCompare = CompareFunction::Always;
+  ds.depthWriteEnabled = false;
+  ds.stencilReadMask = 0xFF;
+  // Cover pass writes zero back so subsequent draws sharing the same render pass see a clean
+  // stencil buffer. The cover quad is sized to fully contain the stencil pass output, so any
+  // pixel that survived the test is reset to 0 here. For inverse fills the surviving pixels
+  // are already zero (path outside region), so the write is a harmless no-op.
+  ds.stencilWriteMask = 0xFF;
+  StencilDescriptor s = {};
+  s.passOp = StencilOperation::Zero;
+  s.failOp = StencilOperation::Zero;
+  s.depthFailOp = StencilOperation::Keep;
+  // Inverse fill paints the "outside" of the path. Both inverse-evenodd and inverse-nonzero
+  // boil down to "shade pixels whose stencil counter is zero", regardless of which counting
+  // rule was used in the stencil pass. The non-inverse case still differs by fill rule
+  // (evenodd uses Invert leaving 0xFF for the inside; nonzero uses Inc/Dec leaving any
+  // non-zero value for the inside).
+  if (IsInverse(fillType)) {
+    s.compare = CompareFunction::Equal;  // ref will be 0
+  } else {
+    s.compare = IsEvenOdd(fillType) ? CompareFunction::Equal : CompareFunction::NotEqual;
+  }
+  ds.stencilFront = s;
+  ds.stencilBack = s;
+  return ds;
+}
+
+// Reference value passed to setStencilReference when issuing the cover draw call. Mirrors
+// the compare-function logic in MakeCoverPassDS — see the comment there for why inverse
+// fills always read against zero.
+uint32_t CoverPassStencilReference(PathFillType fillType) {
+  if (IsInverse(fillType)) {
+    return 0;
+  }
+  return IsEvenOdd(fillType) ? 0xFF : 0;
+}
+
+}  // namespace
+
+PlacementPtr<StencilCoverPathDrawOp> StencilCoverPathDrawOp::Make(
+    std::shared_ptr<StencilCoverPathProxy> geometryProxy, PMColor color, const Matrix& viewMatrix,
+    const Rect& coverLocalBounds, PathFillType fillType) {
+  if (geometryProxy == nullptr) {
+    return nullptr;
+  }
+  auto context = geometryProxy->getContext();
+  if (context == nullptr) {
+    return nullptr;
+  }
+  auto allocator = context->drawingAllocator();
+  return allocator->make<StencilCoverPathDrawOp>(allocator, std::move(geometryProxy), color,
+                                                 viewMatrix, coverLocalBounds, fillType);
+}
+
+StencilCoverPathDrawOp::StencilCoverPathDrawOp(BlockAllocator* allocator,
+                                               std::shared_ptr<StencilCoverPathProxy> geometryProxy,
+                                               PMColor color, const Matrix& viewMatrix,
+                                               const Rect& coverLocalBounds, PathFillType fillType)
+    : DrawOp(allocator, AAType::None), geometryProxy(std::move(geometryProxy)), color(color),
+      viewMatrix(viewMatrix), coverLocalBounds(coverLocalBounds), fillType(fillType) {
+  // The cover quad is built in local space — the cover GP applies the view matrix itself, so
+  // pre-applying it here would double-transform. Inverse fill draws supply a clip-derived
+  // local rect that already covers the inverse region.
+  auto context = this->geometryProxy->getContext();
+  if (context != nullptr) {
+    auto provider = RectsVertexProvider::MakeFrom(allocator, coverLocalBounds, AAType::None);
+    coverQuadBuffer = context->proxyProvider()->createVertexBufferProxy(
+        std::move(provider), RenderFlags::DisableAsyncTask);
+  }
+
+  // Pre-compute the per-op state that only depends on construction-time inputs. This keeps
+  // execute() limited to the work that genuinely needs the live RenderPass / RenderTarget.
+  stencilGP = StencilCoverStencilPassGeometryProcessor::Make(allocator, viewMatrix);
+  stencilPassDS = MakeStencilPassDS(fillType);
+  coverPassDS = MakeCoverPassDS(fillType);
+  coverStencilRef = CoverPassStencilReference(fillType);
+  // The cover quad's device-space footprint is the strict upper bound on where the cover
+  // pass's Zero op will run, so the stencil pass must be scissored to (at most) the same
+  // region — any stencil write outside would leak into subsequent ops sharing the render
+  // pass's depth/stencil attachment.
+  coverDeviceBounds = viewMatrix.mapRect(coverLocalBounds);
+}
+
+bool StencilCoverPathDrawOp::bindStencilPipeline(RenderPass* renderPass,
+                                                 RenderTarget* renderTarget) {
+  if (stencilGP == nullptr) {
+    return false;
+  }
+  // The stencil GP itself was built once at construction time; here we only build the
+  // per-frame ProgramInfo wrapper around it. The pipeline reads the same depth/stencil
+  // attachment that the cover pass uses; OpsRenderTask attached it because needsStencil()
+  // is true.
+  std::vector<FragmentProcessor*> stencilFPs = {};
+  ProgramInfo stencilInfo(renderTarget, stencilGP.get(), std::move(stencilFPs),
+                          /*numColorProcessors=*/0, /*xferProcessor=*/nullptr, BlendMode::SrcOver);
+  // Stencil-and-cover relies on front/back faces using opposite stencil ops (IncrementWrap
+  // vs DecrementWrap) for the non-zero rule. Culling either side would break the winding
+  // count, so the stencil pass is hard-wired to no culling regardless of the op's cullMode.
+  stencilInfo.setCullMode(CullMode::None);
+  stencilInfo.setDepthStencil(stencilPassDS);
+  // Drop colour writes — the stencil pass exists to update the stencil buffer only.
+  stencilInfo.setColorWriteMask(0);
+  auto stencilProgram = stencilInfo.getProgram();
+  if (stencilProgram == nullptr) {
+    LOGE("StencilCoverPathDrawOp::bindStencilPipeline() Failed to get the program!");
+    return false;
+  }
+  renderPass->setPipeline(stencilProgram->getPipeline());
+  stencilInfo.setUniformsAndSamplers(renderPass, stencilProgram.get());
+  // Constrain stencil writes to the cover-quad device bounds intersected with the op's
+  // clip region. See applyStencilScissor() for why relying on DrawOp::applyScissor() alone
+  // is unsafe here.
+  applyStencilScissor(renderPass, renderTarget);
+  return true;
+}
+
+bool StencilCoverPathDrawOp::bindCoverPipeline(RenderPass* renderPass, RenderTarget* renderTarget) {
+  // Build the cover-pass GP. Runs the brush FP chain over a device-bounds quad; the
+  // Loop-Blinn curve test is not needed here because coverage is already locked into the
+  // stencil buffer by the stencil pass.
+  auto coverGP = StencilCoverCoverPassGeometryProcessor::Make(allocator, color, viewMatrix);
+  if (coverGP == nullptr) {
+    return false;
+  }
+  std::vector<FragmentProcessor*> fragmentProcessors = {};
+  fragmentProcessors.reserve(colors.size() + coverages.size());
+  for (auto& colorFP : colors) {
+    fragmentProcessors.emplace_back(colorFP.get());
+  }
+  for (auto& coverageFP : coverages) {
+    fragmentProcessors.emplace_back(coverageFP.get());
+  }
+  ProgramInfo coverInfo(renderTarget, coverGP.get(), std::move(fragmentProcessors), colors.size(),
+                        xferProcessor.get(), blendMode);
+  coverInfo.setCullMode(cullMode);
+  // Route the stencil buffer read through the cover pass. Without this the pipeline would
+  // ignore the stencil buffer and shade every fragment inside the cover quad.
+  coverInfo.setDepthStencil(coverPassDS);
+  auto coverProgram = coverInfo.getProgram();
+  if (coverProgram == nullptr) {
+    LOGE("StencilCoverPathDrawOp::bindCoverPipeline() Failed to get the program!");
+    return false;
+  }
+  renderPass->setPipeline(coverProgram->getPipeline());
+  coverInfo.setUniformsAndSamplers(renderPass, coverProgram.get());
+  applyScissor(renderPass, renderTarget);
+  return true;
+}
+
+void StencilCoverPathDrawOp::applyStencilScissor(RenderPass* renderPass,
+                                                 RenderTarget* renderTarget) const {
+  // Start from the cover-quad's device bounds — the cover pass's Zero stencil op only touches
+  // fragments inside this rect, so any stencil write outside it would never be cleared.
+  Rect stencilRect = coverDeviceBounds;
+  // Intersect with the op's user-supplied scissor (from clip) when present, matching the
+  // cover pass's effective visible area. When scissorRect is empty the cover pass falls back
+  // to "whole render target" — but we still keep the stencil writes clipped to coverDeviceBounds.
+  if (!scissorRect.isEmpty() && !stencilRect.intersect(scissorRect)) {
+    stencilRect.setEmpty();
+  }
+  // Clamp to the render target extent and convert to integer pixel coordinates. Left/top use
+  // floor via truncation of positive values (max(0, ...) rules out negatives), right/bottom
+  // use ceil so no partial-pixel stencil write escapes the scissor.
+  int scissorX = std::max(0, static_cast<int>(stencilRect.left));
+  int scissorY = std::max(0, static_cast<int>(stencilRect.top));
+  int scissorRight =
+      std::min(renderTarget->width(), static_cast<int>(std::ceil(stencilRect.right)));
+  int scissorBottom =
+      std::min(renderTarget->height(), static_cast<int>(std::ceil(stencilRect.bottom)));
+  int scissorWidth = std::max(0, scissorRight - scissorX);
+  int scissorHeight = std::max(0, scissorBottom - scissorY);
+  renderPass->setScissorRect(scissorX, scissorY, scissorWidth, scissorHeight);
+}
+
+void StencilCoverPathDrawOp::execute(RenderPass* renderPass, RenderTarget* renderTarget) {
+  if (geometryProxy == nullptr || coverQuadBuffer == nullptr) {
+    return;
+  }
+  auto coverBuffer = coverQuadBuffer->getBuffer();
+  if (coverBuffer == nullptr) {
+    return;
+  }
+
+  // ----- Stencil pass (skipped when there are no path vertices) -----
+  // An empty vertex stream means the rasterizer produced nothing — either the path is empty
+  // or the only thing to draw is an "everywhere" inverse fill. Either way the stencil buffer
+  // can stay at its cleared zero state; the cover pass will read against zero and shade the
+  // whole quad for inverse fills, or shade nothing for non-inverse empty paths.
+  auto vertexBufferResource = geometryProxy->getVertexBuffer();
+  std::shared_ptr<GPUBuffer> stencilGPUBuffer = nullptr;
+  uint32_t stencilVertexCount = 0;
+  if (vertexBufferResource != nullptr) {
+    stencilGPUBuffer = vertexBufferResource->gpuBuffer();
+    stencilVertexCount =
+        static_cast<uint32_t>(vertexBufferResource->size() / STENCIL_VERTEX_STRIDE);
+  }
+  if (stencilGPUBuffer != nullptr && stencilVertexCount > 0) {
+    if (!bindStencilPipeline(renderPass, renderTarget)) {
+      return;
+    }
+    // Stencil reference is irrelevant for Always + Invert/Inc/Dec, but keep it deterministic.
+    renderPass->setStencilReference(0);
+    renderPass->setVertexBuffer(0, stencilGPUBuffer);
+    renderPass->draw(PrimitiveType::Triangles, stencilVertexCount);
+  }
+
+  // ----- Cover pass -----
+  // Always run the cover pass so inverse fills shade the path's exterior even when the
+  // stencil pass was skipped. StencilCoverPathDrawOp assembles its own cover-pass pipeline
+  // (see bindCoverPipeline) rather than reusing StandardDrawOp's helper — the two rails are
+  // deliberately independent so the "self-managed multi-pass" contract stays visible in the
+  // class hierarchy.
+  if (!bindCoverPipeline(renderPass, renderTarget)) {
+    return;
+  }
+  renderPass->setStencilReference(coverStencilRef);
+  renderPass->setVertexBuffer(0, coverBuffer->gpuBuffer(), coverQuadBuffer->offset());
+  // RectsVertexProvider produces a triangle strip of 4 vertices for non-AA fills.
+  renderPass->draw(PrimitiveType::TriangleStrip, 4);
+}
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/ops/StencilCoverPathDrawOp.h

@@ -0,0 +1,149 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 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.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "DrawOp.h"
+#include "gpu/processors/StencilCoverStencilPassGeometryProcessor.h"
+#include "gpu/proxies/StencilCoverPathProxy.h"
+#include "gpu/proxies/VertexBufferView.h"
+#include "tgfx/core/Matrix.h"
+#include "tgfx/core/PathTypes.h"
+#include "tgfx/core/Rect.h"
+#include "tgfx/gpu/RenderPipeline.h"
+
+namespace tgfx {
+/**
+ * StencilCoverPathDrawOp draws a non-antialiased shape through tgfx's first stencil-based
+ * renderer. The algorithm is a Loop-Blinn quadratic fill (see Loop & Blinn, SIGGRAPH 2005,
+ * referenced from StencilCoverPathTessellator.h) layered on top of an NV_path_rendering-style
+ * stencil-and-cover pipeline. Path geometry is not triangulated on the CPU; instead, every
+ * bezier segment becomes a few triangles carrying KLM coefficients, and the fragment shader
+ * uses the implicit-curve test `k*k - l > 0 ⇒ discard` to obtain pixel-accurate coverage on
+ * the GPU.
+ *
+ * Because the op runs two pipelines (a stencil pass followed by a cover pass) within a single
+ * render pass, it does not inherit from StandardDrawOp — instead it derives from DrawOp
+ * directly and implements execute() itself, binding each pipeline in turn.
+ *
+ * Two passes are run inside execute():
+ *
+ *   1. Stencil pass — uses StencilCoverStencilPassGeometryProcessor to walk the Loop-Blinn
+ *      vertex stream produced by StencilCoverPathTessellator. The fragment shader runs the
+ *      Loop-Blinn test and discards every pixel outside the curve; the configured stencil
+ *      op (Invert for even-odd, IncrementWrap/DecrementWrap for non-zero) then toggles the
+ *      stencil buffer for the surviving pixels, accumulating the fill-rule count.
+ *
+ *   2. Cover pass — re-shades the surviving pixels under a device-bounds quad through the
+ *      brush fragment-processor chain attached by OpsCompositor::addDrawOp. The Loop-Blinn
+ *      test does not run here — coverage is already locked into the stencil buffer.
+ *
+ * Both passes share the same RenderPass; the depth/stencil texture is attached upstream by
+ * OpsRenderTask when needsStencil() returns true.
+ */
+class StencilCoverPathDrawOp : public DrawOp {
+ public:
+  // Upper bound on the number of shapes OpsCompositor may accumulate in its
+  // pendingStencilCoverShapes queue before force-flushing. NOTE: each queued entry is
+  // still emitted as an individual StencilCoverPathDrawOp at flush time — the queue does
+  // not (yet) coalesce shapes into a single instanced draw. The cap exists purely to
+  // bound worst-case memory pressure of the pending queue until an instanced stencil-
+  // cover pipeline lands.
+  static constexpr size_t MaxNumBatched = 1024;
+
+  static PlacementPtr<StencilCoverPathDrawOp> Make(
+      std::shared_ptr<StencilCoverPathProxy> geometryProxy, PMColor color, const Matrix& viewMatrix,
+      const Rect& coverLocalBounds, PathFillType fillType);
+
+  bool hasCoverage() const override {
+    return true;
+  }
+
+  bool needsStencil() const override {
+    return true;
+  }
+
+  void execute(RenderPass* renderPass, RenderTarget* renderTarget) override;
+
+ protected:
+  Type type() override {
+    return Type::StencilCoverPathDrawOp;
+  }
+
+ private:
+  std::shared_ptr<StencilCoverPathProxy> geometryProxy = nullptr;
+  std::shared_ptr<VertexBufferView> coverQuadBuffer = nullptr;
+  PMColor color = PMColor::Transparent();
+  Matrix viewMatrix = {};
+  // The local-space rect that bounds the cover-pass quad. The cover GP applies the view
+  // matrix the same way the stencil pass does, so this rect must be in the path's local
+  // coordinate system (not device space).
+  Rect coverLocalBounds = {};
+  // The device-space bounds of the cover quad, cached at construction time to constrain the
+  // stencil pass scissor. The stencil pass must never write outside this region, otherwise
+  // the cover pass's zeroing sweep will not clear those writes and they leak into subsequent
+  // ops that share the same depth/stencil attachment. Note this bound is used *independently*
+  // of the op's scissorRect: even when scissorRect is empty (no user clip), the stencil pass
+  // is still confined to the cover area.
+  Rect coverDeviceBounds = {};
+  PathFillType fillType = PathFillType::Winding;
+
+  // Stencil-pass GP. Made once at construction time so execute() can reuse it instead of
+  // rebuilding the GP on every command-buffer encode pass.
+  PlacementPtr<StencilCoverStencilPassGeometryProcessor> stencilGP = nullptr;
+
+  // Pre-computed depth/stencil descriptors. Both depend only on `fillType`, so caching them
+  // avoids running the small but per-op MakeStencilPassDS / MakeCoverPassDS branches each
+  // time execute() encodes the stencil and cover passes.
+  DepthStencilDescriptor stencilPassDS = {};
+  DepthStencilDescriptor coverPassDS = {};
+
+  // Pre-computed cover-pass stencil reference value (depends only on fillType).
+  uint32_t coverStencilRef = 0;
+
+  StencilCoverPathDrawOp(BlockAllocator* allocator,
+                         std::shared_ptr<StencilCoverPathProxy> geometryProxy, PMColor color,
+                         const Matrix& viewMatrix, const Rect& coverLocalBounds,
+                         PathFillType fillType);
+
+  // Builds the stencil-pass ProgramInfo (stencil GP, no FP chain, no xfer processor, colour
+  // writes disabled) and binds the resulting pipeline together with its uniforms and samplers
+  // to the render pass. Returns false if program creation fails, in which case the caller
+  // should abort the stencil pass. Also constrains the render pass scissor to the cover-quad
+  // device bounds so no stencil write escapes the region the cover pass will later zero.
+  bool bindStencilPipeline(RenderPass* renderPass, RenderTarget* renderTarget);
+
+  // Builds the cover-pass ProgramInfo from the op's brush FP chain (colors/coverages) and
+  // xfer/blend state, materialises the pipeline, and binds it to the render pass together
+  // with uniforms, samplers and the op's scissor rectangle. Semantically equivalent to what
+  // StandardDrawOp does for single-pipeline ops, but kept as an independent implementation
+  // because StencilCoverPathDrawOp does not derive from StandardDrawOp — the two live on
+  // different rails and share only the underlying ProgramInfo/Program utilities. Returns
+  // false if program creation fails.
+  bool bindCoverPipeline(RenderPass* renderPass, RenderTarget* renderTarget);
+
+  // Sets the render pass scissor to the intersection of the cover-pass device bounds and the
+  // op's clip rect. This is stricter than DrawOp::applyScissor(): when the op has no user
+  // scissor set, applyScissor() would expand to the whole render target, which is unsafe for
+  // the stencil pass because any stencil write outside the cover quad is never cleared by
+  // the cover pass and pollutes the shared depth/stencil attachment.
+  void applyStencilScissor(RenderPass* renderPass, RenderTarget* renderTarget) const;
+
+  friend class BlockAllocator;
+};
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/processors/AlphaThresholdFragmentProcessor.h

@@ -0,0 +1,42 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2024 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.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "gpu/processors/FragmentProcessor.h"
+
+namespace tgfx {
+class AlphaThresholdFragmentProcessor : public FragmentProcessor {
+ public:
+  static PlacementPtr<AlphaThresholdFragmentProcessor> Make(BlockAllocator* allocator,
+                                                            float threshold);
+
+  std::string name() const override {
+    return "AlphaStepFragmentProcessor";
+  }
+
+ protected:
+  DEFINE_PROCESSOR_CLASS_ID
+
+  explicit AlphaThresholdFragmentProcessor(float threshold)
+      : FragmentProcessor(ClassID()), threshold(threshold) {
+  }
+
+  float threshold = 0.0f;
+};
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/processors/AtlasTextGeometryProcessor.cpp

@@ -0,0 +1,46 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "AtlasTextGeometryProcessor.h"
+
+namespace tgfx {
+AtlasTextGeometryProcessor::AtlasTextGeometryProcessor(std::shared_ptr<TextureProxy> textureProxy,
+                                                       AAType aa,
+                                                       std::optional<PMColor> commonColor,
+                                                       const SamplingOptions& sampling)
+    : GeometryProcessor(ClassID()), textureProxy(std::move(textureProxy)), commonColor(commonColor),
+      samplerState(sampling) {
+  position = {"aPosition", VertexFormat::Float2};
+  if (aa == AAType::Coverage) {
+    coverage = {"inCoverage", VertexFormat::Float};
+  }
+  maskCoord = {"maskCoord", VertexFormat::Float2};
+  if (!commonColor.has_value()) {
+    color = {"inColor", VertexFormat::UByte4Normalized};
+  }
+  setVertexAttributes(&position, 4);
+  textures.emplace_back(this->textureProxy->getTextureView()->getTexture());
+  setTextureSamplerCount(textures.size());
+}
+void AtlasTextGeometryProcessor::onComputeProcessorKey(BytesKey* bytesKey) const {
+  uint32_t flags = aa == AAType::Coverage ? 1 : 0;
+  flags |= commonColor.has_value() ? 2 : 0;
+  flags |= textureProxy->isAlphaOnly() ? 4 : 0;
+  bytesKey->write(flags);
+}
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/processors/AtlasTextGeometryProcessor.h

@@ -0,0 +1,65 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <optional>
+#include "GeometryProcessor.h"
+#include "gpu/AAType.h"
+
+namespace tgfx {
+class AtlasTextGeometryProcessor : public GeometryProcessor {
+ public:
+  static PlacementPtr<AtlasTextGeometryProcessor> Make(BlockAllocator* allocator,
+                                                       std::shared_ptr<TextureProxy> textureProxy,
+                                                       AAType aa,
+                                                       std::optional<PMColor> commonColor,
+                                                       const SamplingOptions& sampling);
+  std::string name() const override {
+    return "AtlasTextGeometryProcessor";
+  }
+
+  SamplerState onSamplerStateAt(size_t) const override {
+    return samplerState;
+  }
+
+ protected:
+  DEFINE_PROCESSOR_CLASS_ID
+
+  AtlasTextGeometryProcessor(std::shared_ptr<TextureProxy> textureProxy, AAType aa,
+                             std::optional<PMColor> commonColor, const SamplingOptions& sampling);
+
+  void onComputeProcessorKey(BytesKey* bytesKey) const override;
+
+  std::shared_ptr<Texture> onTextureAt(size_t index) const override {
+    DEBUG_ASSERT(index < textures.size());
+    return textures[index];
+  }
+
+  Attribute position;  // May contain coverage as last channel
+  Attribute coverage;
+  Attribute maskCoord;
+  Attribute color;
+
+  std::shared_ptr<TextureProxy> textureProxy = nullptr;
+  AAType aa = AAType::None;
+  std::optional<PMColor> commonColor = std::nullopt;
+  std::vector<std::shared_ptr<Texture>> textures;
+  SamplerState samplerState = {};
+};
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/gpu/processors/ClampedGradientEffect.cpp

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "ClampedGradientEffect.h"
+
+namespace tgfx {
+ClampedGradientEffect::ClampedGradientEffect(PlacementPtr<FragmentProcessor> colorizer,
+                                             PlacementPtr<FragmentProcessor> gradLayout,
+                                             Color leftBorderColor, Color rightBorderColor)
+    : FragmentProcessor(ClassID()), leftBorderColor(leftBorderColor),
+      rightBorderColor(rightBorderColor) {
+  colorizerIndex = registerChildProcessor(std::move(colorizer));
+  gradLayoutIndex = registerChildProcessor(std::move(gradLayout));
+}
+}  // namespace tgfx