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

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

@@ -0,0 +1,120 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 <vector>
+#include "tgfx/core/Point.h"
+
+namespace tgfx {
+class PathUtils {
+ public:
+  /**
+   * When tessellating curved paths into linear segments, this defines the maximum distance in
+   * screen space which a segment may deviate from the mathematically correct value. Above this
+   * value, the segment will be subdivided. This value was chosen to approximate the super sampling
+   * accuracy of the raster path (16 samples, or one quarter pixel).
+   */
+  static constexpr float DefaultTolerance = 0.25f;
+
+  /**
+   * Converts a cubic bezier curve into a sequence of quadratic bezier curves.
+   *
+   * cubicPoints is an array of 4 points defining the cubic curve.
+   * tolerance is the maximum allowed deviation from the original curve.
+   * quads is the output buffer, appended to in-place; callers may reuse the same vector
+   * across multiple invocations to avoid repeated heap allocations. Each emitted quad takes
+   * three consecutive entries (start, control, end). The buffer is not cleared on entry.
+   */
+  static void ConvertCubicToQuads(const Point cubicPoints[4], float tolerance,
+                                  std::vector<Point>* quads);
+
+  /**
+   * Subdivides a quadratic bezier curve at parameter t.
+   *
+   * source is an array of 3 points defining the input quadratic curve.
+   * destination is an array of 5 points to receive the two resulting quadratic curves.
+   * t is the subdivision parameter in the range [0, 1].
+   */
+  static void ChopQuadAt(const Point source[3], Point destination[5], float t);
+
+  /**
+   * Finds the parameter t at the point of maximum curvature on a quadratic bezier curve.
+   *
+   * source is an array of 3 points defining the quadratic curve.
+   * Returns the t value for the point of maximum curvature if it exists on the segment,
+   * otherwise returns 0.
+   */
+  static float FindQuadMaxCurvature(const Point source[3]);
+
+  /**
+   * Subdivides a quadratic bezier curve at the point of maximum curvature if it exists.
+   *
+   * source is an array of 3 points defining the input quadratic curve.
+   * destination is an array of 5 points to receive the subdivided curves.
+   * Returns 1 if no subdivision occurred (destination[0..2] contains the original quad).
+   * Returns 2 if subdivision occurred (destination[0..2] and destination[2..4] contain the two new quads).
+   */
+  static int ChopQuadAtMaxCurvature(const Point source[3], Point destination[5]);
+};
+
+/**
+ * QuadUVMatrix computes a transformation matrix that maps vertex positions to UV coordinates
+ * for quadratic bezier curve rendering on GPU based on the Loop-Blinn algorithm.
+ * The UV coordinates are used in fragment shaders to determine pixel coverage for anti-aliased
+ * curve rendering.
+ *
+ * The matrix transforms control points [P0, P1, P2] to UV space:
+ *   P0 -> (0, 0)
+ *   P1 -> (0.5, 0)
+ *   P2 -> (1, 1)
+ *
+ * In fragment shader, pixels where u^2 < v are inside the curve.
+ */
+class QuadUVMatrix {
+ public:
+  QuadUVMatrix() = default;
+
+  /**
+   * Initializes the matrix from quadratic bezier control points.
+   *
+   * controlPoints is an array of 3 points defining the quadratic curve.
+   */
+  explicit QuadUVMatrix(const Point controlPoints[3]);
+
+  /**
+   * Sets the matrix from quadratic bezier control points.
+   *
+   * controlPoints is an array of 3 points defining the quadratic curve.
+   */
+  void set(const Point controlPoints[3]);
+
+  /**
+   * Applies the matrix to vertex positions to compute UV coords.
+   *
+   * vertices is a pointer to the first vertex.
+   * vertexCount is the number of vertices.
+   * stride is the size of each vertex.
+   * uvOffset is the offset of the UV values within each vertex.
+   */
+  void apply(void* vertices, int vertexCount, size_t stride, size_t uvOffset) const;
+
+ private:
+  float matrix[6] = {};
+};
+}  // namespace tgfx

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

@@ -0,0 +1,80 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "PixelFormatUtil.h"
+
+namespace tgfx {
+PixelFormat ColorTypeToPixelFormat(ColorType type) {
+  switch (type) {
+    case ColorType::RGBA_8888:
+      return PixelFormat::RGBA_8888;
+    case ColorType::ALPHA_8:
+      return PixelFormat::ALPHA_8;
+    case ColorType::BGRA_8888:
+      return PixelFormat::BGRA_8888;
+    case ColorType::Gray_8:
+      return PixelFormat::GRAY_8;
+    default:
+      return PixelFormat::Unknown;
+  }
+}
+
+ColorType PixelFormatToColorType(PixelFormat format) {
+  switch (format) {
+    case PixelFormat::RGBA_8888:
+      return ColorType::RGBA_8888;
+    case PixelFormat::ALPHA_8:
+      return ColorType::ALPHA_8;
+    case PixelFormat::BGRA_8888:
+      return ColorType::BGRA_8888;
+    case PixelFormat::GRAY_8:
+      return ColorType::Gray_8;
+    default:
+      return ColorType::Unknown;
+  }
+}
+
+size_t PixelFormatBytesPerPixel(PixelFormat format) {
+  switch (format) {
+    case PixelFormat::ALPHA_8:
+    case PixelFormat::GRAY_8:
+      return 1;
+    case PixelFormat::RG_88:
+      return 2;
+    case PixelFormat::RGBA_8888:
+    case PixelFormat::BGRA_8888:
+      return 4;
+    default:
+      return 0;
+  }
+}
+
+PixelFormat MaskFormatToPixelFormat(MaskFormat format) {
+  switch (format) {
+    case MaskFormat::A8:
+      return PixelFormat::ALPHA_8;
+    case MaskFormat::RGBA:
+      return PixelFormat::RGBA_8888;
+    case MaskFormat::BGRA:
+      return PixelFormat::BGRA_8888;
+    default:
+      return PixelFormat::Unknown;
+  }
+}
+
+}  // namespace tgfx

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

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 <cstdio>
+#include "core/AtlasTypes.h"
+#include "tgfx/core/ImageInfo.h"
+#include "tgfx/gpu/PixelFormat.h"
+
+namespace tgfx {
+PixelFormat ColorTypeToPixelFormat(ColorType type);
+
+ColorType PixelFormatToColorType(PixelFormat format);
+
+size_t PixelFormatBytesPerPixel(PixelFormat format);
+
+PixelFormat MaskFormatToPixelFormat(MaskFormat format);
+
+}  // namespace tgfx

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

@@ -0,0 +1,252 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "core/utils/Log.h"
+#include "core/utils/PlacementPtr.h"
+
+namespace tgfx {
+/**
+ * PlacementArray is a simple array-like container that holds a list of PlacementPtr pointers in
+ * pre-allocated memory. It is similar to std::array, but does not manage the memory itself.
+ */
+template <typename T>
+class PlacementArray {
+ public:
+  /**
+   * Constructs an empty PlacementArray.
+   */
+  PlacementArray() = default;
+
+  ~PlacementArray() {
+    clear();
+  }
+
+  PlacementArray(const PlacementArray&) = delete;
+
+  PlacementArray& operator=(const PlacementArray&) = delete;
+
+  /**
+   * Constructs a PlacementArray by moving from another PlacementArray.
+   */
+  PlacementArray(PlacementArray&& other) noexcept : _data(other._data), _size(other._size) {
+    other._data = nullptr;
+    other._size = 0;
+  }
+
+  /**
+   * Constructs a PlacementArray from another PlacementArray of a different type.
+   */
+  template <typename U>
+  PlacementArray(PlacementArray<U>&& other) noexcept : _data(other._data), _size(other.size) {
+    static_assert(std::is_base_of_v<T, U>, "U must be derived from T!");
+    other._data = nullptr;
+    other._size = 0;
+  }
+
+  /**
+   * Assigns a PlacementArray by moving from another PlacementArray.
+   */
+  PlacementArray& operator=(PlacementArray&& other) noexcept {
+    if (this != &other) {
+      clear();
+      _data = other._data;
+      _size = other._size;
+      other._data = nullptr;
+      other._size = 0;
+    }
+    return *this;
+  }
+
+  /**
+   * Returns the number of elements in the PlacementArray.
+   */
+  size_t size() const {
+    return _size;
+  }
+
+  /**
+   * Returns true if the PlacementArray is empty.
+   */
+  bool empty() const {
+    return _size == 0;
+  }
+
+  /**
+   * Clears the PlacementArray, destroying all elements.
+   */
+  void clear() {
+    if (_size > 0) {
+      for (size_t i = 0; i < _size; ++i) {
+        _data[i].~PlacementPtr<T>();
+      }
+      _data = nullptr;
+      _size = 0;
+    }
+  }
+
+  /**
+   * Returns a pointer to the element at the specified index.
+   */
+  PlacementPtr<T>& operator[](size_t index) {
+    DEBUG_ASSERT(index < _size);
+    return _data[index];
+  }
+
+  /**
+   * Returns a pointer to the element at the specified index.
+   */
+  const PlacementPtr<T>& operator[](size_t index) const {
+    DEBUG_ASSERT(index < _size);
+    return _data[index];
+  }
+
+  /**
+   * Returns a pointer to the element at the front of the PlacementArray.
+   */
+  PlacementPtr<T>& front() {
+    DEBUG_ASSERT(_size > 0);
+    return _data[0];
+  }
+
+  /**
+   * Returns a pointer to the element at the front of the PlacementArray.
+   */
+  const PlacementPtr<T>& front() const {
+    DEBUG_ASSERT(_size > 0);
+    return _data[0];
+  }
+
+  /**
+   * Returns a pointer to the element at the back of the PlacementArray.
+   */
+  PlacementPtr<T>& back() {
+    DEBUG_ASSERT(_size > 0);
+    return _data[_size - 1];
+  }
+
+  /**
+   * Returns a pointer to the element at the back of the PlacementArray.
+   */
+  const PlacementPtr<T>& back() const {
+    DEBUG_ASSERT(_size > 0);
+    return _data[_size - 1];
+  }
+
+  /**
+   * Returns a pointer to the underlying data of the PlacementArray.
+   */
+  PlacementPtr<T>* data() {
+    return _data;
+  }
+
+  /**
+   * The iterator class for the PlacementArray. It allows iterating over the elements in the array.
+   */
+  class Iterator {
+   public:
+    Iterator(PlacementPtr<T>* data, size_t index) : data(data), index(index) {
+    }
+
+    Iterator& operator++() {
+      ++index;
+      return *this;
+    }
+
+    bool operator!=(const Iterator& other) const {
+      return index != other.index;
+    }
+
+    PlacementPtr<T>& operator*() {
+      return data[index];
+    }
+
+   private:
+    PlacementPtr<T>* data = nullptr;
+    size_t index = 0;
+  };
+
+  /**
+   * Returns an iterator to the beginning of the PlacementArray.
+   */
+  Iterator begin() {
+    return Iterator(_data, 0);
+  }
+
+  /**
+   * Returns an iterator to the end of the PlacementArray.
+   */
+  Iterator end() {
+    return Iterator(_data, _size);
+  }
+
+  /**
+   * The const iterator class for the PlacementArray. It allows iterating over the elements in the
+   * array.
+   */
+  class ConstIterator {
+   public:
+    ConstIterator(const PlacementPtr<T>* data, size_t index) : data(data), index(index) {
+    }
+
+    ConstIterator& operator++() {
+      ++index;
+      return *this;
+    }
+
+    bool operator!=(const ConstIterator& other) const {
+      return index != other.index;
+    }
+
+    const PlacementPtr<T>& operator*() const {
+      return data[index];
+    }
+
+   private:
+    const PlacementPtr<T>* data = nullptr;
+    size_t index = 0;
+  };
+
+  /**
+   * Returns a const iterator to the beginning of the PlacementArray.
+   */
+  ConstIterator begin() const {
+    return ConstIterator(_data, 0);
+  }
+
+  /**
+   * Returns a const iterator to the end of the PlacementArray.
+   */
+  ConstIterator end() const {
+    return ConstIterator(_data, _size);
+  }
+
+ private:
+  PlacementPtr<T>* _data = nullptr;
+  size_t _size = 0;
+
+  /**
+   * Constructs a PlacementArray with the specified data and size.
+   */
+  PlacementArray(PlacementPtr<T>* data, size_t size) : _data(data), _size(size) {
+  }
+
+  friend class BlockAllocator;
+};
+}  // namespace tgfx

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

@@ -0,0 +1,183 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 <cstddef>
+#include <type_traits>
+
+namespace tgfx {
+/**
+ * A smart pointer that manages the lifetime of an object allocated in a pre-allocated chunk of
+ * memory. The object is constructed in-place and destroyed when the pointer goes out of scope. It
+ * is similar to std::unique_ptr, but it does not own the memory, meaning it does not free the
+ * memory when it goes out of scope.
+ */
+template <typename T>
+class PlacementPtr {
+ public:
+  /**
+   * Constructs a PlacementPtr with a nullptr.
+   */
+  PlacementPtr() : pointer(nullptr) {
+  }
+
+  /**
+   * Constructs a PlacementPtr with the given pointer. The pointer must be allocated in a
+   * pre-allocated memory block.
+   */
+  explicit PlacementPtr(T* pointer) : pointer(pointer) {
+  }
+
+  /**
+   * Constructs a PlacementPtr with a nullptr.
+   */
+  PlacementPtr(std::nullptr_t) : pointer(nullptr) {
+  }
+
+  /**
+   * Destroys the PlacementPtr and calls the destructor of the object.
+   */
+  ~PlacementPtr() {
+    if (pointer) {
+      pointer->~T();
+    }
+  }
+
+  /**
+   * Constructs a PlacementPtr by moving the pointer from another PlacementPtr.
+   */
+  PlacementPtr(PlacementPtr&& other) noexcept : pointer(other.pointer) {
+    other.pointer = nullptr;
+  }
+
+  /**
+   * Constructs a PlacementPtr by moving the pointer from another PlacementPtr of a different type.
+   */
+  template <typename U>
+  PlacementPtr(PlacementPtr<U>&& other) noexcept : pointer(other.pointer) {
+    static_assert(std::is_base_of_v<T, U>, "U must be derived from T!");
+    other.pointer = nullptr;
+  }
+
+  PlacementPtr(const PlacementPtr&) = delete;
+  PlacementPtr& operator=(const PlacementPtr&) = delete;
+
+  /**
+   * Assigns a PlacementPtr to the PlacementPtr by moving the pointer from the other PlacementPtr.
+   */
+  PlacementPtr& operator=(PlacementPtr&& other) noexcept {
+    if (this != &other) {
+      if (pointer) {
+        pointer->~T();
+      }
+      pointer = other.pointer;
+      other.pointer = nullptr;
+    }
+    return *this;
+  }
+
+  /**
+   * Assigns a nullptr to the PlacementPtr.
+   */
+  PlacementPtr& operator=(std::nullptr_t) noexcept {
+    if (pointer) {
+      pointer->~T();
+    }
+    pointer = nullptr;
+    return *this;
+  }
+
+  /**
+   * Assigns a PlacementPtr of a different type to the PlacementPtr by moving the pointer from the
+   * other PlacementPtr.
+   */
+  template <typename U>
+  PlacementPtr& operator=(PlacementPtr<U>&& other) noexcept {
+    if (pointer != other.pointer) {
+      if (pointer) {
+        pointer->~T();
+      }
+      pointer = other.pointer;
+      other.pointer = nullptr;
+    }
+    return *this;
+  }
+
+  /**
+   * Returns true if the PlacementPtr is equal to another PlacementPtr.
+   */
+  bool operator==(const PlacementPtr& other) const {
+    return pointer == other.pointer;
+  }
+
+  /**
+   * Returns true if the PlacementPtr is not equal to another PlacementPtr.
+   */
+  bool operator!=(const PlacementPtr& other) const {
+    return pointer != other.pointer;
+  }
+
+  /**
+   * Returns true if the PlacementPtr is not equal to a nullptr.
+   */
+  explicit operator bool() const {
+    return pointer != nullptr;
+  }
+
+  /**
+   * Returns the raw pointer.
+   */
+  T* get() const {
+    return pointer;
+  }
+
+  /**
+   * Resets the pointer to nullptr and calls the destructor of the object.
+   */
+  void reset(T* ptr = nullptr) {
+    if (pointer) {
+      pointer->~T();
+    }
+    pointer = ptr;
+  }
+
+  /**
+   * Releases the ownership of the pointer and returns the raw pointer.
+   */
+  T* release() {
+    T* temp = pointer;
+    pointer = nullptr;
+    return temp;
+  }
+
+  T& operator*() const {
+    return *pointer;
+  }
+
+  T* operator->() const {
+    return pointer;
+  }
+
+ private:
+  T* pointer = nullptr;
+
+  template <typename U>
+  friend class PlacementPtr;
+};
+}  // namespace tgfx