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

package/cpp/third_party/tgfx/src/core/utils/NextCacheScaleLevel.cpp

@@ -0,0 +1,47 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "NextCacheScaleLevel.h"
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+
+namespace tgfx {
+
+float NextCacheScaleLevel(float scale) {
+#ifndef TGFX_USE_THREADS
+  // In single-threaded builds, on-demand codec downscaling runs on the main thread and offers no
+  // latency benefit, while multi-level caching multiplies total decode time across draws. Keep a
+  // single full-size texture and rely on GPU sampling for downscaling instead.
+  (void)scale;
+  return 1.0f;
+#else
+  constexpr float MinAllowedImageScale = 1.0f / 8.0f;
+  if (scale <= MinAllowedImageScale) {
+    return MinAllowedImageScale;
+  }
+  if (scale > 0.5f) {
+    return 1.0f;
+  }
+  float exactLevel = std::log2(1.0f / scale);
+  auto scaleLevel = static_cast<uint32_t>(std::floor(exactLevel));
+  return 1.0f / static_cast<float>(1 << scaleLevel);
+#endif
+}
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/core/utils/NextCacheScaleLevel.h

@@ -0,0 +1,25 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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
+
+namespace tgfx {
+
+float NextCacheScaleLevel(float scale);
+
+}

package/cpp/third_party/tgfx/src/core/utils/OrientationHelper.h

@@ -0,0 +1,100 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "tgfx/core/Orientation.h"
+
+namespace tgfx {
+/*
+ * @param data           Buffer to read bytes from
+ * @param isLittleEndian Output parameter
+ *                       Indicates if the data is little endian
+ *                       Is unaffected on false returns
+ */
+inline bool is_valid_endian_marker(const uint8_t* data, bool* isLittleEndian) {
+  // II indicates Intel (little endian) and MM indicates motorola (big endian).
+  if (('I' != data[0] || 'I' != data[1]) && ('M' != data[0] || 'M' != data[1])) {
+    return false;
+  }
+
+  *isLittleEndian = ('I' == data[0]);
+  return true;
+}
+
+inline uint32_t get_endian_int(const uint8_t* data, bool littleEndian) {
+  if (littleEndian) {
+    return static_cast<uint32_t>((data[3] << 24) | (data[2] << 16) | (data[1] << 8) | (data[0]));
+  }
+
+  return static_cast<uint32_t>((data[0] << 24) | (data[1] << 16) | (data[2] << 8) | (data[3]));
+}
+
+inline uint16_t get_endian_short(const uint8_t* data, bool littleEndian) {
+  if (littleEndian) {
+    return static_cast<uint16_t>((data[1] << 8) | (data[0]));
+  }
+
+  return static_cast<uint16_t>((data[0] << 8) | (data[1]));
+}
+
+static bool is_orientation_marker(const uint8_t* data, size_t data_length,
+                                  Orientation* orientation) {
+  bool littleEndian;
+  // We need eight bytes to read the endian marker and the offset, below.
+  if (data_length < 8 || !is_valid_endian_marker(data, &littleEndian)) {
+    return false;
+  }
+
+  // Get the offset from the start of the marker.
+  // Though this only reads four bytes, use a larger int in case it overflows.
+  uint64_t offset = get_endian_int(data + 4, littleEndian);
+
+  // Require that the marker is at least large enough to contain the number of entries.
+  if (data_length < offset + 2) {
+    return false;
+  }
+  uint32_t numEntries = get_endian_short(data + offset, littleEndian);
+
+  // Tag (2 bytes), Datatype (2 bytes), Number of elements (4 bytes), Data (4 bytes)
+  const uint32_t kEntrySize = 12;
+  const auto max = static_cast<uint32_t>((data_length - offset - 2) / kEntrySize);
+  numEntries = numEntries < max ? numEntries : max;
+
+  // Advance the data to the start of the entries.
+  data += offset + 2;
+
+  const uint16_t kOriginTag = 0x112;
+  const uint16_t kOriginType = 3;
+  for (uint32_t i = 0; i < numEntries; i++, data += kEntrySize) {
+    uint16_t tag = get_endian_short(data, littleEndian);
+    uint16_t type = get_endian_short(data + 2, littleEndian);
+    uint32_t count = get_endian_int(data + 4, littleEndian);
+    if (kOriginTag == tag && kOriginType == type && 1 == count) {
+      uint16_t val = get_endian_short(data + 8, littleEndian);
+      if (0 < val && val <= static_cast<int>(Orientation::LeftBottom)) {
+        *orientation = (Orientation)val;
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/core/utils/PathUtils.cpp

@@ -0,0 +1,479 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "core/utils/PathUtils.h"
+#include "core/utils/Log.h"
+#include "core/utils/MathExtra.h"
+#include "core/utils/PointUtils.h"
+#include "tgfx/core/Point.h"
+
+namespace tgfx {
+
+namespace {
+
+constexpr float CUBIC_TO_QUAD_LENGTH_SCALE = 1.5f;
+constexpr int CUBIC_TO_QUAD_MAX_SUBDIVS = 10;
+
+inline Point Interp(const Point& v0, const Point& v1, float t) {
+  return v0 + (v1 - v0) * t;
+}
+
+int ValidUnitDivide(float numer, float denom, float* ratio) {
+  DEBUG_ASSERT(ratio);
+  if (numer < 0) {
+    numer = -numer;
+    denom = -denom;
+  }
+
+  if (denom == 0 || numer == 0 || numer >= denom) {
+    return 0;
+  }
+
+  float r = numer / denom;
+  if (std::isnan(r)) {
+    return 0;
+  }
+  DEBUG_ASSERT((r >= 0 && r < 1.f));
+  if (r == 0) {
+    return 0;
+  }
+  *ratio = r;
+  return 1;
+}
+
+int FindUnitQuadRoots(float A, float B, float C, float roots[2]) {
+  DEBUG_ASSERT(roots);
+
+  if (A == 0) {
+    return ValidUnitDivide(-C, B, roots);
+  }
+
+  auto* r = roots;
+  // Use double precision to prevent overflow
+  double doubleRadius = static_cast<double>(B * B) - (4.0 * static_cast<double>(A * C));
+  if (doubleRadius < 0) {
+    return 0;
+  }
+  doubleRadius = std::sqrt(doubleRadius);
+  auto radius = static_cast<float>(doubleRadius);
+  if (!FloatsAreFinite(&radius, 1)) {
+    return 0;
+  }
+
+  float Q = (B < 0) ? -(B - radius) / 2 : -(B + radius) / 2;
+  r += ValidUnitDivide(Q, A, r);
+  r += ValidUnitDivide(C, Q, r);
+  if (r - roots == 2) {
+    if (roots[0] > roots[1]) {
+      using std::swap;
+      swap(roots[0], roots[1]);
+    } else if (roots[0] == roots[1]) {
+      r -= 1;
+    }
+  }
+  return static_cast<int>(r - roots);
+}
+
+int FindCubicInflections(const Point src[4], float tValues[2]) {
+  float Ax = src[1].x - src[0].x;
+  float Ay = src[1].y - src[0].y;
+  float Bx = src[2].x - (2 * src[1].x) + src[0].x;
+  float By = src[2].y - (2 * src[1].y) + src[0].y;
+  float Cx = src[3].x + (3 * (src[1].x - src[2].x)) - src[0].x;
+  float Cy = src[3].y + (3 * (src[1].y - src[2].y)) - src[0].y;
+
+  return FindUnitQuadRoots((Bx * Cy) - (By * Cx), (Ax * Cy) - (Ay * Cx), (Ax * By) - (Ay * Bx),
+                           tValues);
+}
+
+// TODO(YGaurora): Consider SIMD optimization using Highway to vectorize interpolation.
+void ChopCubicAt(const Point source[4], Point destination[7], float t) {
+  DEBUG_ASSERT((0 <= t && t <= 1));
+
+  if (t == 1) {
+    memcpy(destination, source, sizeof(Point) * 4);
+    destination[4] = destination[5] = destination[6] = source[3];
+    return;
+  }
+
+  auto p0 = source[0];
+  auto p1 = source[1];
+  auto p2 = source[2];
+  auto p3 = source[3];
+
+  auto ab = Interp(p0, p1, t);
+  auto bc = Interp(p1, p2, t);
+  auto cd = Interp(p2, p3, t);
+  auto abc = Interp(ab, bc, t);
+  auto bcd = Interp(bc, cd, t);
+  auto abcd = Interp(abc, bcd, t);
+
+  destination[0] = p0;
+  destination[1] = ab;
+  destination[2] = abc;
+  destination[3] = abcd;
+  destination[4] = bcd;
+  destination[5] = cd;
+  destination[6] = p3;
+}
+
+// TODO(YGaurora): Consider SIMD optimization using Highway to vectorize interpolation.
+void ChopCubicAt(const Point source[4], Point destination[10], float t0, float t1) {
+  DEBUG_ASSERT((0 <= t0 && t0 <= t1 && t1 <= 1));
+
+  if (t1 == 1) {
+    ChopCubicAt(source, destination, t0);
+    destination[7] = destination[8] = destination[9] = source[3];
+    return;
+  }
+
+  // Perform two chops simultaneously. The data layout is optimized for potential
+  // compiler auto-vectorization: arrays store [t0_result, t1_result] pairs.
+  auto p0 = source[0];
+  auto p1 = source[1];
+  auto p2 = source[2];
+  auto p3 = source[3];
+  float t[2] = {t0, t1};
+
+  Point ab[2];
+  Point bc[2];
+  Point cd[2];
+  Point abc[2];
+  Point bcd[2];
+  Point abcd[2];
+  Point middle[2];
+
+  for (int i = 0; i < 2; ++i) {
+    ab[i] = Interp(p0, p1, t[i]);
+    bc[i] = Interp(p1, p2, t[i]);
+    cd[i] = Interp(p2, p3, t[i]);
+    abc[i] = Interp(ab[i], bc[i], t[i]);
+    bcd[i] = Interp(bc[i], cd[i], t[i]);
+    abcd[i] = Interp(abc[i], bcd[i], t[i]);
+  }
+  middle[0] = Interp(abc[0], bcd[0], t[1]);
+  middle[1] = Interp(abc[1], bcd[1], t[0]);
+
+  destination[0] = p0;
+  destination[1] = ab[0];
+  destination[2] = abc[0];
+  destination[3] = abcd[0];
+  destination[4] = middle[0];
+  destination[5] = middle[1];
+  destination[6] = abcd[1];
+  destination[7] = bcd[1];
+  destination[8] = cd[1];
+  destination[9] = p3;
+}
+
+void ChopCubicAt(const Point source[4], Point destination[], const float toleranceValues[],
+                 int toleranceCount) {
+  DEBUG_ASSERT(std::all_of(toleranceValues, toleranceValues + toleranceCount,
+                           [](float t) { return t >= 0 && t <= 1; }));
+  DEBUG_ASSERT(std::is_sorted(toleranceValues, toleranceValues + toleranceCount));
+
+  if (destination) {
+    if (toleranceCount == 0) {  // nothing to chop
+      memcpy(destination, source, 4 * sizeof(Point));
+    } else {
+      float lastTolerance = 0.f;
+      int i = 0;
+      for (; i < toleranceCount - 1; i += 2) {
+        // Do two chops at once.
+        float tolerance1 = toleranceValues[i];
+        float tolerance2 = toleranceValues[i + 1];
+        tolerance1 = std::clamp((tolerance1 - lastTolerance) / (1 - lastTolerance), 0.f, 1.f);
+        tolerance2 = std::clamp((tolerance2 - lastTolerance) / (1 - lastTolerance), 0.f, 1.f);
+        ChopCubicAt(source, destination, tolerance1, tolerance2);
+        lastTolerance = toleranceValues[i + 1];
+        source = destination = destination + 6;
+      }
+      if (i < toleranceCount) {
+        // Chop the final cubic if there was an odd number of chops.
+        DEBUG_ASSERT(i + 1 == toleranceCount);
+        float tolerance = toleranceValues[i];
+        tolerance = std::clamp((tolerance - lastTolerance) / (1 - lastTolerance), 0.f, 1.f);
+        ChopCubicAt(source, destination, tolerance);
+      }
+    }
+  }
+}
+
+void ChopCubicAtHalf(const Point source[4], Point destination[7]) {
+  ChopCubicAt(source, destination, 0.5f);
+}
+
+int ChopCubicAtInflections(const Point source[4], Point destination[10]) {
+  float toleranceValues[2];
+  int count = FindCubicInflections(source, toleranceValues);
+
+  if (destination) {
+    if (count == 0) {
+      memcpy(destination, source, 4 * sizeof(Point));
+    } else {
+      ChopCubicAt(source, destination, toleranceValues, count);
+    }
+  }
+  return count + 1;
+}
+
+void ConvertNoninflectCubicToQuads(const Point p[4], float toleranceSqd, std::vector<Point>& quads,
+                                   int sublevel = 0, bool preserveFirstTangent = true,
+                                   bool preserveLastTangent = true) {
+  // Notation: Point a is always p[0]. Point b is p[1] unless p[1] == p[0], in which case it is
+  // p[2]. Point d is always p[3]. Point c is p[2] unless p[2] == p[3], in which case it is p[1].
+  auto ab = p[1] - p[0];
+  auto dc = p[2] - p[3];
+
+  if (Point::DotProduct(ab, ab) < FLOAT_NEARLY_ZERO) {
+    if (Point::DotProduct(dc, dc) < FLOAT_NEARLY_ZERO) {
+      quads.push_back(p[0]);
+      quads.push_back(p[0]);
+      quads.push_back(p[3]);
+      return;
+    }
+    ab = p[2] - p[0];
+  }
+  if (Point::DotProduct(dc, dc) < FLOAT_NEARLY_ZERO) {
+    dc = p[1] - p[3];
+  }
+
+  ab *= CUBIC_TO_QUAD_LENGTH_SCALE;
+  dc *= CUBIC_TO_QUAD_LENGTH_SCALE;
+
+  // c0 and c1 are extrapolations along vectors ab and dc.
+  auto c0 = p[0] + ab;
+  auto c1 = p[3] + dc;
+
+  // When recursion depth exceeds the limit, force distanceSqd to 0 to accept the approximation.
+  // This prevents infinite recursion while maintaining acceptable visual quality, as curves
+  // requiring more than CUBIC_TO_QUAD_MAX_SUBDIVS levels are already extremely well-approximated.
+  float distanceSqd =
+      sublevel > CUBIC_TO_QUAD_MAX_SUBDIVS ? 0 : PointUtils::DistanceSquared(c0, c1);
+  if (distanceSqd < toleranceSqd) {
+    Point newC;
+    if (preserveFirstTangent == preserveLastTangent) {
+      // We used to force a split when both tangents need to be preserved and c0 != c1.
+      // This introduced a large performance regression for tiny paths for no noticeable
+      // quality improvement. However, we aren't quite fulfilling our contract of guaranteeing
+      // the two tangent vectors and this could introduce a missed pixel in
+      // AAHairlinePathRenderer.
+      newC = (c0 + c1) * 0.5f;
+    } else if (preserveFirstTangent) {
+      newC = c0;
+    } else {
+      newC = c1;
+    }
+
+    quads.push_back(p[0]);
+    quads.push_back(newC);
+    quads.push_back(p[3]);
+    return;
+  }
+  Point choppedPoints[7];
+  ChopCubicAtHalf(p, choppedPoints);
+  ConvertNoninflectCubicToQuads(choppedPoints + 0, toleranceSqd, quads, sublevel + 1,
+                                preserveFirstTangent, false);
+  ConvertNoninflectCubicToQuads(choppedPoints + 3, toleranceSqd, quads, sublevel + 1, false,
+                                preserveLastTangent);
+}
+
+}  // namespace
+
+void PathUtils::ConvertCubicToQuads(const Point cubicPoints[4], float tolerance,
+                                    std::vector<Point>* quads) {
+  if (quads == nullptr || !FloatsAreFinite(&tolerance, 1)) {
+    return;
+  }
+  Point chopped[10];
+  int count = ChopCubicAtInflections(cubicPoints, chopped);
+
+  float toleranceSquare = tolerance * tolerance;
+
+  for (int i = 0; i < count; ++i) {
+    Point* cubic = chopped + (3 * i);
+    ConvertNoninflectCubicToQuads(cubic, toleranceSquare, *quads);
+  }
+}
+
+void PathUtils::ChopQuadAt(const Point source[3], Point destination[5], float t) {
+  DEBUG_ASSERT((t > 0.f && t < 1.f));
+
+  auto p0 = source[0];
+  auto p1 = source[1];
+  auto p2 = source[2];
+
+  auto p01 = Interp(p0, p1, t);
+  auto p12 = Interp(p1, p2, t);
+
+  destination[0] = p0;
+  destination[1] = p01;
+  destination[2] = Interp(p01, p12, t);
+  destination[3] = p12;
+  destination[4] = p2;
+}
+
+float PathUtils::FindQuadMaxCurvature(const Point source[3]) {
+  float Ax = source[1].x - source[0].x;
+  float Ay = source[1].y - source[0].y;
+  float Bx = source[0].x - source[1].x - source[1].x + source[2].x;
+  float By = source[0].y - source[1].y - source[1].y + source[2].y;
+
+  float numer = -((Ax * Bx) + (Ay * By));
+  float denom = (Bx * Bx) + (By * By);
+  if (denom < 0) {
+    numer = -numer;
+    denom = -denom;
+  }
+  if (numer <= 0) {
+    return 0;
+  }
+  if (numer >= denom) {  // Also catches denom=0.
+    return 1;
+  }
+  float t = numer / denom;
+  DEBUG_ASSERT(((0 <= t && t < 1) || std::isnan(t)));
+  return t;
+}
+
+int PathUtils::ChopQuadAtMaxCurvature(const Point source[3], Point destination[5]) {
+  float t = FindQuadMaxCurvature(source);
+  if (t > 0 && t < 1) {
+    ChopQuadAt(source, destination, t);
+    return 2;
+  } else {
+    memcpy(destination, source, 3 * sizeof(Point));
+    return 1;
+  }
+}
+
+QuadUVMatrix::QuadUVMatrix(const Point controlPoints[3]) {
+  this->set(controlPoints);
+}
+
+void QuadUVMatrix::set(const Point controlPoints[3]) {
+  // We want M such that M * xy_pt = uv_pt
+  // We know M * control_pts = [0  1/2 1]
+  //                           [0  0   1]
+  //                           [1  1   1]
+  // And control_pts = [x0 x1 x2]
+  //                   [y0 y1 y2]
+  //                   [1  1  1 ]
+  // We invert the control pt matrix and post concat to both sides to get M.
+  // Using the known form of the control point matrix and the result, we can
+  // optimize and improve precision.
+
+  double x0 = controlPoints[0].x;
+  double y0 = controlPoints[0].y;
+  double x1 = controlPoints[1].x;
+  double y1 = controlPoints[1].y;
+  double x2 = controlPoints[2].x;
+  double y2 = controlPoints[2].y;
+
+  // pre-calculate some adjugate matrix factors for determinant
+  double a2 = (x1 * y2) - (x2 * y1);
+  double a5 = (x2 * y0) - (x0 * y2);
+  double a8 = (x0 * y1) - (x1 * y0);
+  double det = a2 + a5 + a8;
+
+  if (!std::isfinite(det) ||
+      FloatNearlyZero(static_cast<float>(det), FLOAT_NEARLY_ZERO * FLOAT_NEARLY_ZERO)) {
+    // The quad is degenerate. Hopefully this is rare. Find the pts that are
+    // farthest apart to compute a line (unless it is really a pt).
+    auto maxD = PointUtils::DistanceSquared(controlPoints[0], controlPoints[1]);
+    int maxEdge = 0;
+    auto d = PointUtils::DistanceSquared(controlPoints[1], controlPoints[2]);
+    if (d > maxD) {
+      maxD = d;
+      maxEdge = 1;
+    }
+    d = PointUtils::DistanceSquared(controlPoints[2], controlPoints[0]);
+    if (d > maxD) {
+      maxD = d;
+      maxEdge = 2;
+    }
+    // We could have a tolerance here, not sure if it would improve anything
+    if (maxD > 0) {
+      // Set the matrix to give (u = 0, v = distance_to_line)
+      auto lineVec = controlPoints[(maxEdge + 1) % 3] - controlPoints[maxEdge];
+      // when looking from the point 0 down the line we want positive
+      // distances to be to the left. This matches the non-degenerate
+      // case.
+      lineVec = PointUtils::MakeOrthogonal(lineVec, PointUtils::Side::Left);
+      // first row
+      matrix[0] = 0;
+      matrix[1] = 0;
+      matrix[2] = 0;
+      // second row
+      matrix[3] = lineVec.x;
+      matrix[4] = lineVec.y;
+      matrix[5] = -Point::DotProduct(lineVec, controlPoints[maxEdge]);
+    } else {
+      // It's a point. It should cover zero area. Just set the matrix such
+      // that (u, v) will always be far away from the quad.
+      matrix[0] = 0;
+      matrix[1] = 0;
+      matrix[2] = 100.f;
+      matrix[3] = 0;
+      matrix[4] = 0;
+      matrix[5] = 100.f;
+    }
+  } else {
+    double scale = 1.0 / det;
+
+    // compute adjugate matrix
+    double a3 = y2 - y0;
+    double a4 = x0 - x2;
+    double a6 = y0 - y1;
+    double a7 = x1 - x0;
+
+    // this performs the uv_pts * adjugate(control_pts) multiply,
+    // then does the scale by 1/det afterwards to improve precision
+    matrix[0] = static_cast<float>((0.5 * a3 + a6) * scale);
+    matrix[1] = static_cast<float>((0.5 * a4 + a7) * scale);
+    matrix[2] = static_cast<float>((0.5 * a5 + a8) * scale);
+    matrix[3] = static_cast<float>(a6 * scale);
+    matrix[4] = static_cast<float>(a7 * scale);
+    matrix[5] = static_cast<float>(a8 * scale);
+  }
+}
+
+void QuadUVMatrix::apply(void* vertices, int vertexCount, size_t stride, size_t uvOffset) const {
+  DEBUG_ASSERT(vertices != nullptr);
+  if (vertexCount <= 0) {
+    return;
+  }
+  auto* xyPtr = static_cast<char*>(vertices);
+  auto* uvPtr = static_cast<char*>(vertices) + uvOffset;
+  float sx = matrix[0];
+  float kx = matrix[1];
+  float tx = matrix[2];
+  float ky = matrix[3];
+  float sy = matrix[4];
+  float ty = matrix[5];
+  for (int i = 0; i < vertexCount; ++i) {
+    auto* xy = reinterpret_cast<const Point*>(xyPtr);
+    auto* uv = reinterpret_cast<Point*>(uvPtr);
+    uv->x = sx * xy->x + kx * xy->y + tx;
+    uv->y = ky * xy->x + sy * xy->y + ty;
+    xyPtr += stride;
+    uvPtr += stride;
+  }
+}
+
+}  // namespace tgfx