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

package/cpp/third_party/tgfx/src/core/PictureRecords.h

@@ -0,0 +1,419 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "core/DrawContext.h"
+#include "core/PlaybackContext.h"
+
+namespace tgfx {
+enum class PictureRecordType {
+  SetMatrix,
+  SetClip,
+  SetColor,
+  SetFill,
+  SetStrokeWidth,
+  SetStroke,
+  SetHasStroke,
+  DrawFill,
+  DrawRect,
+  DrawRRect,
+  DrawPath,
+  DrawShape,
+  DrawMesh,
+  DrawImage,
+  DrawImageRect,
+  DrawImageRectToRect,
+  DrawTextBlob,
+  DrawPicture,
+  DrawLayer
+};
+
+class PictureRecord {
+ public:
+  virtual ~PictureRecord() = default;
+
+  virtual PictureRecordType type() const = 0;
+
+  virtual bool hasUnboundedFill(bool& /*hasInverseClip*/) const {
+    return false;
+  }
+
+  virtual void playback(DrawContext* context, PlaybackContext* playback) const = 0;
+};
+
+class SetMatrix : public PictureRecord {
+ public:
+  explicit SetMatrix(const Matrix& matrix) : matrix(matrix) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::SetMatrix;
+  }
+
+  void playback(DrawContext*, PlaybackContext* playback) const override {
+    playback->setMatrix(matrix);
+  }
+
+  Matrix matrix = {};
+};
+
+class SetClip : public PictureRecord {
+ public:
+  explicit SetClip(ClipStack clip) : clip(std::move(clip)) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::SetClip;
+  }
+
+  bool hasUnboundedFill(bool& hasInverseClip) const override {
+    // WideOpen means no clip restriction, equivalent to inverse fill behavior for DrawFill.
+    if (clip.state() == ClipState::WideOpen) {
+      hasInverseClip = true;
+      return false;
+    }
+
+    auto& elements = clip.elements();
+    for (size_t i = clip.oldestValidIndex(); i < elements.size(); ++i) {
+      const auto& element = elements[i];
+      if (element.isValid() && element.shape().isPath() &&
+          element.shape().path().isInverseFillType()) {
+        hasInverseClip = true;
+        return false;
+      }
+    }
+    hasInverseClip = false;
+    return false;
+  }
+
+  void playback(DrawContext*, PlaybackContext* playback) const override {
+    playback->setClip(clip);
+  }
+
+  ClipStack clip = {};
+};
+
+class SetColor : public PictureRecord {
+ public:
+  explicit SetColor(Color color) : color(color) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::SetColor;
+  }
+
+  void playback(DrawContext*, PlaybackContext* playback) const override {
+    playback->setColor(color);
+  }
+
+  Color color = {};
+};
+
+class SetBrush : public PictureRecord {
+ public:
+  explicit SetBrush(Brush brush) : brush(std::move(brush)) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::SetFill;
+  }
+
+  void playback(DrawContext*, PlaybackContext* playback) const override {
+    playback->setBrush(brush);
+  }
+
+  Brush brush = {};
+};
+
+class SetStrokeWidth : public PictureRecord {
+ public:
+  explicit SetStrokeWidth(float width) : width(width) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::SetStrokeWidth;
+  }
+
+  void playback(DrawContext*, PlaybackContext* playback) const override {
+    playback->setStrokeWidth(width);
+  }
+
+  float width = 0.0f;
+};
+
+class SetStroke : public PictureRecord {
+ public:
+  explicit SetStroke(const Stroke& stroke) : stroke(stroke) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::SetStroke;
+  }
+
+  void playback(DrawContext*, PlaybackContext* playback) const override {
+    playback->setStroke(stroke);
+  }
+
+  Stroke stroke = {};
+};
+
+class SetHasStroke : public PictureRecord {
+ public:
+  explicit SetHasStroke(bool hasStroke) : hasStroke(hasStroke) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::SetHasStroke;
+  }
+
+  void playback(DrawContext*, PlaybackContext* playback) const override {
+    playback->setHasStroke(hasStroke);
+  }
+
+  bool hasStroke = false;
+};
+
+class DrawFill : public PictureRecord {
+ public:
+  PictureRecordType type() const override {
+    return PictureRecordType::DrawFill;
+  }
+
+  bool hasUnboundedFill(bool& hasInverseClip) const override {
+    return hasInverseClip;
+  }
+
+  void playback(DrawContext* context, PlaybackContext* playback) const override {
+    playback->drawFill(context);
+  }
+};
+
+class DrawRect : public PictureRecord {
+ public:
+  explicit DrawRect(const Rect& rect) : rect(rect) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::DrawRect;
+  }
+
+  void playback(DrawContext* context, PlaybackContext* playback) const override {
+    context->drawRect(rect, playback->matrix(), playback->clip(), playback->brush(),
+                      playback->stroke());
+  }
+
+  Rect rect = {};
+};
+
+class DrawRRect : public PictureRecord {
+ public:
+  explicit DrawRRect(const RRect& rRect) : rRect(rRect) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::DrawRRect;
+  }
+
+  void playback(DrawContext* context, PlaybackContext* playback) const override {
+    context->drawRRect(rRect, playback->matrix(), playback->clip(), playback->brush(),
+                       playback->stroke());
+  }
+
+  RRect rRect = {};
+};
+
+class DrawPath : public PictureRecord {
+ public:
+  explicit DrawPath(Path path) : path(std::move(path)) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::DrawPath;
+  }
+
+  bool hasUnboundedFill(bool& hasInverseClip) const override {
+    return hasInverseClip && path.isInverseFillType();
+  }
+
+  void playback(DrawContext* context, PlaybackContext* playback) const override {
+    context->drawPath(path, playback->matrix(), playback->clip(), playback->brush());
+  }
+
+  Path path = {};
+};
+
+class DrawShape : public PictureRecord {
+ public:
+  explicit DrawShape(std::shared_ptr<Shape> shape) : shape(std::move(shape)) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::DrawShape;
+  }
+
+  bool hasUnboundedFill(bool& hasInverseClip) const override {
+    return hasInverseClip && shape->isInverseFillType();
+  }
+
+  void playback(DrawContext* context, PlaybackContext* playback) const override {
+    context->drawShape(shape, playback->matrix(), playback->clip(), playback->brush(),
+                       playback->stroke());
+  }
+
+  std::shared_ptr<Shape> shape = nullptr;
+};
+
+class DrawMesh : public PictureRecord {
+ public:
+  explicit DrawMesh(std::shared_ptr<Mesh> mesh) : mesh(std::move(mesh)) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::DrawMesh;
+  }
+
+  void playback(DrawContext* context, PlaybackContext* playback) const override {
+    context->drawMesh(mesh, playback->matrix(), playback->clip(), playback->brush());
+  }
+
+  std::shared_ptr<Mesh> mesh = nullptr;
+};
+
+class DrawImage : public PictureRecord {
+ public:
+  DrawImage(std::shared_ptr<Image> image, const SamplingOptions& sampling)
+      : image(std::move(image)), sampling(sampling) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::DrawImage;
+  }
+
+  void playback(DrawContext* context, PlaybackContext* playback) const override {
+    context->drawImage(image, sampling, playback->matrix(), playback->clip(), playback->brush());
+  }
+
+  std::shared_ptr<Image> image = nullptr;
+  SamplingOptions sampling = {};
+};
+
+class DrawImageRect : public DrawImage {
+ public:
+  DrawImageRect(std::shared_ptr<Image> image, const Rect& rect, const SamplingOptions& sampling,
+                SrcRectConstraint constraint, const Rect& strictRect = Rect::MakeEmpty())
+      : DrawImage(std::move(image), sampling), rect(rect), constraint(constraint),
+        strictRect(strictRect) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::DrawImageRect;
+  }
+
+  void playback(DrawContext* context, PlaybackContext* playback) const override {
+    const Rect* strictRectPtr = strictRect.isEmpty() ? nullptr : &strictRect;
+    context->drawImageRect(image, rect, rect, sampling, playback->matrix(), playback->clip(),
+                           playback->brush(), constraint, strictRectPtr);
+  }
+
+  Rect rect;
+  SrcRectConstraint constraint = SrcRectConstraint::Fast;
+  Rect strictRect = Rect::MakeEmpty();
+};
+
+class DrawImageRectToRect : public DrawImageRect {
+ public:
+  DrawImageRectToRect(std::shared_ptr<Image> image, const Rect& srcRect, const Rect& dstRect,
+                      const SamplingOptions& sampling, SrcRectConstraint constraint,
+                      const Rect& strictRect = Rect::MakeEmpty())
+      : DrawImageRect(std::move(image), srcRect, sampling, constraint, strictRect),
+        dstRect(dstRect) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::DrawImageRectToRect;
+  }
+
+  void playback(DrawContext* context, PlaybackContext* playback) const override {
+    const Rect* strictRectPtr = strictRect.isEmpty() ? nullptr : &strictRect;
+    context->drawImageRect(image, rect, dstRect, sampling, playback->matrix(), playback->clip(),
+                           playback->brush(), constraint, strictRectPtr);
+  }
+
+  Rect dstRect = {};
+};
+
+class DrawTextBlob : public PictureRecord {
+ public:
+  explicit DrawTextBlob(std::shared_ptr<TextBlob> textBlob) : textBlob(std::move(textBlob)) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::DrawTextBlob;
+  }
+
+  void playback(DrawContext* context, PlaybackContext* playback) const override {
+    context->drawTextBlob(textBlob, playback->matrix(), playback->clip(), playback->brush(),
+                          playback->stroke());
+  }
+
+  std::shared_ptr<TextBlob> textBlob = nullptr;
+};
+
+class DrawPicture : public PictureRecord {
+ public:
+  explicit DrawPicture(std::shared_ptr<Picture> picture) : picture(std::move(picture)) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::DrawPicture;
+  }
+
+  bool hasUnboundedFill(bool& hasInverseClip) const override {
+    return hasInverseClip && picture->hasUnboundedFill();
+  }
+
+  void playback(DrawContext* context, PlaybackContext* playback) const override {
+    context->drawPicture(picture, playback->matrix(), playback->clip());
+  }
+
+  std::shared_ptr<Picture> picture = nullptr;
+};
+
+class DrawLayer : public PictureRecord {
+ public:
+  DrawLayer(std::shared_ptr<Picture> picture, std::shared_ptr<ImageFilter> filter)
+      : picture(std::move(picture)), filter(std::move(filter)) {
+  }
+
+  PictureRecordType type() const override {
+    return PictureRecordType::DrawLayer;
+  }
+
+  bool hasUnboundedFill(bool& hasInverseClip) const override {
+    return hasInverseClip && picture->hasUnboundedFill();
+  }
+
+  void playback(DrawContext* context, PlaybackContext* playback) const override {
+    context->drawLayer(picture, filter, playback->matrix(), playback->clip(), playback->brush());
+  }
+
+  std::shared_ptr<Picture> picture = nullptr;
+  std::shared_ptr<ImageFilter> filter = nullptr;
+};
+}  // namespace tgfx

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

@@ -0,0 +1,158 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "core/PixelBuffer.h"
+#include "core/utils/HardwareBufferUtil.h"
+#include "core/utils/PixelFormatUtil.h"
+#include "tgfx/gpu/Device.h"
+
+namespace tgfx {
+class RasterPixelBuffer : public PixelBuffer {
+ public:
+  RasterPixelBuffer(const ImageInfo& info, uint8_t* pixels) : PixelBuffer(info), _pixels(pixels) {
+  }
+
+  ~RasterPixelBuffer() override {
+    delete[] _pixels;
+  }
+
+  bool isHardwareBacked() const override {
+    return false;
+  }
+
+  HardwareBufferRef getHardwareBuffer() const override {
+    return nullptr;
+  }
+
+ protected:
+  void* onLockPixels() const override {
+    return _pixels;
+  }
+
+  void onUnlockPixels() const override {
+  }
+
+  std::shared_ptr<TextureView> onBindToHardwareTexture(Context*) const override {
+    return nullptr;
+  }
+
+ private:
+  uint8_t* _pixels = nullptr;
+};
+
+class HardwarePixelBuffer : public PixelBuffer {
+ public:
+  HardwarePixelBuffer(const ImageInfo& info, HardwareBufferRef hardwareBuffer)
+      : PixelBuffer(info), hardwareBuffer(HardwareBufferRetain(hardwareBuffer)) {
+  }
+
+  ~HardwarePixelBuffer() override {
+    HardwareBufferRelease(hardwareBuffer);
+  }
+
+  bool isHardwareBacked() const override {
+    return HardwareBufferCheck(hardwareBuffer);
+  }
+
+  HardwareBufferRef getHardwareBuffer() const override {
+    return isHardwareBacked() ? hardwareBuffer : nullptr;
+  }
+
+ protected:
+  void* onLockPixels() const override {
+    return HardwareBufferLock(hardwareBuffer);
+  }
+
+  void onUnlockPixels() const override {
+    HardwareBufferUnlock(hardwareBuffer);
+  }
+
+  std::shared_ptr<TextureView> onBindToHardwareTexture(Context* context) const override {
+    return TextureView::MakeFrom(context, hardwareBuffer);
+  }
+
+ private:
+  HardwareBufferRef hardwareBuffer;
+};
+
+std::shared_ptr<PixelBuffer> PixelBuffer::Make(int width, int height, bool alphaOnly,
+                                               bool tryHardware,
+                                               std::shared_ptr<ColorSpace> colorSpace) {
+  if (width <= 0 || height <= 0) {
+    return nullptr;
+  }
+  if (tryHardware) {
+    auto hardwareBuffer = HardwareBufferAllocate(width, height, alphaOnly);
+    auto pixelBuffer = PixelBuffer::MakeFrom(hardwareBuffer, colorSpace);
+    HardwareBufferRelease(hardwareBuffer);
+    if (pixelBuffer != nullptr) {
+      return pixelBuffer;
+    }
+  }
+  auto colorType = alphaOnly ? ColorType::ALPHA_8 : ColorType::RGBA_8888;
+  auto info =
+      ImageInfo::Make(width, height, colorType, AlphaType::Premultiplied, 0, std::move(colorSpace));
+  if (info.isEmpty()) {
+    return nullptr;
+  }
+  auto pixels = new (std::nothrow) uint8_t[info.byteSize()];
+  if (pixels == nullptr) {
+    return nullptr;
+  }
+  return std::make_shared<RasterPixelBuffer>(info, pixels);
+}
+
+std::shared_ptr<PixelBuffer> PixelBuffer::MakeFrom(HardwareBufferRef hardwareBuffer,
+                                                   std::shared_ptr<ColorSpace> colorSpace) {
+  auto info = GetImageInfo(hardwareBuffer, std::move(colorSpace));
+  return info.isEmpty() ? nullptr : std::make_shared<HardwarePixelBuffer>(info, hardwareBuffer);
+}
+
+PixelBuffer::PixelBuffer(const ImageInfo& info) : _info(info) {
+}
+
+void* PixelBuffer::lockPixels() {
+  locker.lock();
+  auto pixels = onLockPixels();
+  if (pixels == nullptr) {
+    locker.unlock();
+  }
+  return pixels;
+}
+
+void PixelBuffer::unlockPixels() {
+  onUnlockPixels();
+  locker.unlock();
+}
+
+std::shared_ptr<TextureView> PixelBuffer::onMakeTexture(Context* context, bool mipmapped) const {
+  std::lock_guard<std::mutex> autoLock(locker);
+  if (!mipmapped && isHardwareBacked()) {
+    return onBindToHardwareTexture(context);
+  }
+  auto pixels = onLockPixels();
+  if (pixels == nullptr) {
+    return nullptr;
+  }
+  auto format = ColorTypeToPixelFormat(_info.colorType());
+  auto textureView = TextureView::MakeFormat(context, width(), height(), pixels, _info.rowBytes(),
+                                             format, mipmapped);
+  onUnlockPixels();
+  return textureView;
+}
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/core/PixelBuffer.h

@@ -0,0 +1,113 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "gpu/resources/TextureView.h"
+#include "tgfx/core/ImageBuffer.h"
+#include "tgfx/platform/HardwareBuffer.h"
+
+namespace tgfx {
+/**
+ * A container for writable pixel memory. PixelBuffer is thread safe.
+ */
+class PixelBuffer : public ImageBuffer {
+ public:
+  /**
+   * Creates a new PixelBuffer object width specified width and height. Returns nullptr if width or
+   * height is not greater than zero. If the alphaOnly is true, sets colorType to
+   * ColorType::ALPHA_8, otherwise sets to the native 32-bit color type of the current platform. If
+   * the tryHardware is true, a PixelBuffer backed by hardware is returned if it is available on the
+   * current platform. Otherwise, a CPU-backed PixelBuffer is returned.
+   */
+  static std::shared_ptr<PixelBuffer> Make(int width, int height, bool alphaOnly = false,
+                                           bool tryHardware = true,
+                                           std::shared_ptr<ColorSpace> colorSpace = nullptr);
+
+  /**
+   * Creates a PixelBuffer from the specified hardware buffer. Returns nullptr if the hardwareBuffer
+   * is invalid or the current platform has no hardware buffer support.
+   */
+  static std::shared_ptr<PixelBuffer> MakeFrom(HardwareBufferRef hardwareBuffer,
+                                               std::shared_ptr<ColorSpace> colorSpace = nullptr);
+
+  int width() const override {
+    return _info.width();
+  }
+
+  int height() const override {
+    return _info.height();
+  }
+
+  bool isAlphaOnly() const override {
+    return _info.isAlphaOnly();
+  }
+
+  const std::shared_ptr<ColorSpace>& colorSpace() const override {
+    return _info.colorSpace();
+  }
+
+  /**
+   * Returns an ImageInfo describing the width, height, color type, alpha type, and row bytes of the
+   * PixelBuffer.
+   */
+  const ImageInfo& info() const {
+    return _info;
+  }
+
+  /**
+   * Locks and returns the address of the pixels to ensure that the memory is accessible.
+   */
+  void* lockPixels();
+
+  /**
+   * Call this to balance a successful call to lockPixels().
+   */
+  void unlockPixels();
+
+  /**
+   * Returns true if this pixel buffer is hardware backed. A hardware-backed PixelBuffer allows
+   * sharing buffers across CPU and GPU, which can be used to speed up the texture uploading.
+   */
+  virtual bool isHardwareBacked() const = 0;
+
+  /**
+   * Retrieves the backing hardware buffer. This method does not acquire any additional reference to
+   * the returned hardware buffer. Returns nullptr if the PixelBuffer is not backed by a hardware
+   * buffer.
+   */
+  virtual HardwareBufferRef getHardwareBuffer() const = 0;
+
+ protected:
+  explicit PixelBuffer(const ImageInfo& info);
+
+  bool isPixelBuffer() const final {
+    return true;
+  }
+
+  std::shared_ptr<TextureView> onMakeTexture(Context* context, bool mipmapped) const override;
+
+  virtual void* onLockPixels() const = 0;
+  virtual void onUnlockPixels() const = 0;
+  virtual std::shared_ptr<TextureView> onBindToHardwareTexture(Context* context) const = 0;
+
+ private:
+  mutable std::mutex locker = {};
+  ImageInfo _info = {};
+};
+}  // namespace tgfx