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

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

@@ -0,0 +1,292 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "tgfx/core/Surface.h"
+#include "core/images/TextureImage.h"
+#include "core/utils/CopyPixels.h"
+#include "core/utils/Log.h"
+#include "core/utils/MathExtra.h"
+#include "core/utils/PixelFormatUtil.h"
+#include "gpu/DrawingManager.h"
+#include "gpu/ProxyProvider.h"
+#include "gpu/RenderContext.h"
+#include "tgfx/gpu/GPU.h"
+#include "tgfx/gpu/Window.h"
+
+namespace tgfx {
+std::shared_ptr<Surface> Surface::Make(Context* context, int width, int height, bool alphaOnly,
+                                       int sampleCount, bool mipmapped, uint32_t renderFlags,
+                                       std::shared_ptr<ColorSpace> colorSpace) {
+  return Make(context, width, height, alphaOnly ? ColorType::ALPHA_8 : ColorType::RGBA_8888,
+              sampleCount, mipmapped, renderFlags, std::move(colorSpace));
+}
+
+std::shared_ptr<Surface> Surface::Make(Context* context, int width, int height, ColorType colorType,
+                                       int sampleCount, bool mipmapped, uint32_t renderFlags,
+                                       std::shared_ptr<ColorSpace> colorSpace) {
+  if (context == nullptr) {
+    return nullptr;
+  }
+  auto pixelFormat = ColorTypeToPixelFormat(colorType);
+  auto proxy = context->proxyProvider()->createRenderTargetProxy({}, width, height, pixelFormat,
+                                                                 sampleCount, mipmapped);
+  return MakeFrom(std::move(proxy), renderFlags, true, std::move(colorSpace));
+}
+
+std::shared_ptr<Surface> Surface::MakeFrom(Context* context,
+                                           const BackendRenderTarget& renderTarget,
+                                           ImageOrigin origin, uint32_t renderFlags,
+                                           std::shared_ptr<ColorSpace> colorSpace) {
+  if (context == nullptr) {
+    return nullptr;
+  }
+  auto proxy = RenderTargetProxy::MakeFrom(context, renderTarget, origin);
+  return MakeFrom(std::move(proxy), renderFlags, false, std::move(colorSpace));
+}
+
+std::shared_ptr<Surface> Surface::MakeFrom(Context* context, const BackendTexture& backendTexture,
+                                           ImageOrigin origin, int sampleCount,
+                                           uint32_t renderFlags,
+                                           std::shared_ptr<ColorSpace> colorSpace) {
+  if (context == nullptr) {
+    return nullptr;
+  }
+  auto proxy =
+      context->proxyProvider()->createRenderTargetProxy(backendTexture, sampleCount, origin);
+  return MakeFrom(std::move(proxy), renderFlags, false, std::move(colorSpace));
+}
+
+std::shared_ptr<Surface> Surface::MakeFrom(Context* context, HardwareBufferRef hardwareBuffer,
+                                           int sampleCount, uint32_t renderFlags,
+                                           std::shared_ptr<ColorSpace> colorSpace) {
+  if (context == nullptr) {
+    return nullptr;
+  }
+  auto proxy = context->proxyProvider()->createRenderTargetProxy(hardwareBuffer, sampleCount);
+  return MakeFrom(std::move(proxy), renderFlags, false, std::move(colorSpace));
+}
+
+std::shared_ptr<Surface> Surface::MakeFrom(Context* context, std::shared_ptr<Window> window,
+                                           uint32_t renderFlags) {
+  if (context == nullptr || window == nullptr) {
+    return nullptr;
+  }
+  auto proxy = window->onCreateRenderTarget(context);
+  if (proxy == nullptr) {
+    return nullptr;
+  }
+  auto colorSpace = window->colorSpace();
+  return MakeFrom(std::move(proxy), renderFlags, true, std::move(colorSpace), std::move(window));
+}
+
+std::shared_ptr<Surface> Surface::MakeFrom(std::shared_ptr<RenderTargetProxy> renderTargetProxy,
+                                           uint32_t renderFlags, bool clearAll,
+                                           std::shared_ptr<ColorSpace> colorSpace,
+                                           std::shared_ptr<Window> window) {
+  if (renderTargetProxy == nullptr) {
+    return nullptr;
+  }
+  return std::shared_ptr<Surface>(new Surface(std::move(renderTargetProxy), renderFlags, clearAll,
+                                              std::move(colorSpace), window));
+}
+
+Surface::Surface(std::shared_ptr<RenderTargetProxy> proxy, uint32_t renderFlags, bool clearAll,
+                 std::shared_ptr<ColorSpace> colorSpace, std::shared_ptr<Window> window)
+    : _uniqueID(UniqueID::Next()), _window(std::move(window)) {
+  DEBUG_ASSERT(proxy != nullptr);
+  renderContext =
+      new RenderContext(std::move(proxy), renderFlags, clearAll, this, std::move(colorSpace));
+}
+
+Surface::~Surface() {
+  delete canvas;
+  delete renderContext;
+}
+
+Context* Surface::getContext() const {
+  return renderContext->getContext();
+}
+
+uint32_t Surface::renderFlags() const {
+  return renderContext->renderFlags;
+}
+
+int Surface::width() const {
+  return renderContext->renderTarget->width();
+}
+
+int Surface::height() const {
+  return renderContext->renderTarget->height();
+}
+
+ImageOrigin Surface::origin() const {
+  return renderContext->renderTarget->origin();
+}
+
+BackendRenderTarget Surface::getBackendRenderTarget() {
+  getContext()->flushAndSubmit();
+  auto renderTarget = renderContext->renderTarget->getRenderTarget();
+  if (renderTarget == nullptr) {
+    return {};
+  }
+  return renderTarget->getBackendRenderTarget();
+}
+
+BackendTexture Surface::getBackendTexture() {
+  auto textureProxy = renderContext->renderTarget->asTextureProxy();
+  if (textureProxy == nullptr) {
+    return {};
+  }
+  getContext()->flushAndSubmit();
+  auto textureView = textureProxy->getTextureView();
+  if (textureView == nullptr) {
+    return {};
+  }
+  return textureView->getBackendTexture();
+}
+
+HardwareBufferRef Surface::getHardwareBuffer() {
+  auto textureProxy = renderContext->renderTarget->asTextureProxy();
+  if (textureProxy == nullptr) {
+    return {};
+  }
+  getContext()->flushAndSubmit(true);
+  auto textureView = textureProxy->getTextureView();
+  if (textureView == nullptr) {
+    return nullptr;
+  }
+  return textureView->getTexture()->getHardwareBuffer();
+}
+
+Canvas* Surface::getCanvas() {
+  if (canvas == nullptr) {
+    canvas = new Canvas(renderContext, this);
+  }
+  return canvas;
+}
+
+std::shared_ptr<Image> Surface::makeImageSnapshot() {
+  if (cachedImage != nullptr) {
+    return cachedImage;
+  }
+  auto renderTarget = renderContext->renderTarget;
+  auto drawingManager = getContext()->drawingManager();
+  renderContext->flush();
+  auto textureProxy = renderTarget->asTextureProxy();
+  if (textureProxy == nullptr || renderTarget->externallyOwned()) {
+    textureProxy = renderTarget->makeTextureProxy();
+    drawingManager->addRenderTargetCopyTask(renderTarget, textureProxy);
+  }
+  cachedImage = TextureImage::Wrap(std::move(textureProxy), colorSpace());
+  return cachedImage;
+}
+
+RGBA4f<AlphaType::Premultiplied> Surface::getColor(int x, int y,
+                                                   std::shared_ptr<ColorSpace> dstColorSpace) {
+  auto dstInfo = ImageInfo::Make(1, 1, ColorType::RGBA_F16, AlphaType::Premultiplied, 8,
+                                 std::move(dstColorSpace));
+  uint16_t color[4];
+  if (!readPixels(dstInfo, color, x, y)) {
+    return RGBA4f<AlphaType::Premultiplied>::Transparent();
+  }
+  return {HalfToFloat(color[0]), HalfToFloat(color[1]), HalfToFloat(color[2]),
+          HalfToFloat(color[3])};
+}
+
+std::shared_ptr<SurfaceReadback> Surface::asyncReadPixels(const Rect& rect) {
+  if (rect.isEmpty()) {
+    return nullptr;
+  }
+  auto surfaceRect = Rect::MakeWH(width(), height());
+  if (!surfaceRect.contains(rect)) {
+    return nullptr;
+  }
+  auto renderTarget = renderContext->renderTarget;
+  auto srcRect = renderTarget->getOriginTransform().mapRect(rect);
+  auto colorType = PixelFormatToColorType(renderTarget->format());
+  auto context = renderTarget->getContext();
+  auto rowBytes = static_cast<size_t>(srcRect.width()) * ImageInfo::GetBytesPerPixel(colorType);
+  auto alignment = static_cast<size_t>(context->gpu()->limits()->minBufferCopyRowAlignment);
+  if (alignment > 1) {
+    rowBytes = (rowBytes + alignment - 1) & ~(alignment - 1);
+  }
+  auto info = ImageInfo::Make(static_cast<int>(srcRect.width()), static_cast<int>(srcRect.height()),
+                              colorType, AlphaType::Premultiplied, rowBytes, colorSpace());
+  auto readbackBuffer = context->proxyProvider()->createReadbackBufferProxy(info.byteSize());
+  if (readbackBuffer == nullptr) {
+    return nullptr;
+  }
+  renderContext->flush();
+  context->drawingManager()->addTransferPixelsTask(renderTarget, srcRect, readbackBuffer);
+  return std::shared_ptr<SurfaceReadback>(new SurfaceReadback(info, std::move(readbackBuffer)));
+}
+
+bool Surface::readPixels(const ImageInfo& dstInfo, void* dstPixels, int srcX, int srcY) {
+  auto renderTarget = renderContext->renderTarget;
+  auto outInfo = dstInfo.makeIntersect(-srcX, -srcY, renderTarget->width(), renderTarget->height());
+  if (outInfo.isEmpty() || dstPixels == nullptr) {
+    return false;
+  }
+  dstPixels = dstInfo.computeOffset(dstPixels, -srcX, -srcY);
+  auto readX = std::max(0, srcX);
+  auto readY = std::max(0, srcY);
+  auto rect = Rect::MakeXYWH(readX, readY, outInfo.width(), outInfo.height());
+  auto readback = asyncReadPixels(rect);
+  if (readback == nullptr) {
+    return false;
+  }
+  auto context = renderTarget->getContext();
+  auto srcPixels = readback->lockPixels(context);
+  if (srcPixels == nullptr) {
+    return false;
+  }
+  auto flipY = renderTarget->origin() == ImageOrigin::BottomLeft;
+  // Use the readback's ImageInfo which has the correct aligned rowBytes for GPU buffer layout.
+  auto srcInfo = readback->info();
+  CopyPixels(srcInfo, srcPixels, outInfo, dstPixels, flipY);
+  readback->unlockPixels(context);
+  return true;
+}
+
+const std::shared_ptr<ColorSpace>& Surface::colorSpace() const {
+  return renderContext->colorSpace();
+}
+
+bool Surface::aboutToDraw(bool discardContent) {
+  if (cachedImage == nullptr) {
+    return true;
+  }
+  auto isUnique = cachedImage.use_count() == 1;
+  auto oldContent = discardContent ? nullptr : cachedImage;
+  cachedImage = nullptr;
+  if (isUnique) {
+    return true;
+  }
+  auto renderTarget = renderContext->renderTarget;
+  if (renderTarget->externallyOwned()) {
+    return true;
+  }
+  auto newRenderTarget = renderTarget->makeRenderTargetProxy();
+  if (newRenderTarget == nullptr) {
+    LOGE("Surface::aboutToDraw(): Failed to make a copy of the renderTarget!");
+    return false;
+  }
+  renderContext->replaceRenderTarget(std::move(newRenderTarget), std::move(oldContent));
+  return true;
+}
+}  // namespace tgfx

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

@@ -0,0 +1,143 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "tgfx/core/SurfaceReadback.h"
+#include "core/utils/CopyPixels.h"
+#include "core/utils/Log.h"
+#include "gpu/proxies/GPUBufferProxy.h"
+#include "tgfx/gpu/GPU.h"
+#include "tgfx/gpu/GPUBuffer.h"
+
+namespace tgfx {
+SurfaceReadback::~SurfaceReadback() {
+  DEBUG_ASSERT(!locked);
+  if (flipYPixels != nullptr) {
+    free(flipYPixels);
+  }
+}
+
+bool SurfaceReadback::isReady(Context* context) const {
+  if (context != proxy->getContext()) {
+    LOGE("SurfaceReadback::isReady() Context mismatch!");
+    return false;
+  }
+  auto readbackBuffer = proxy->getBuffer();
+  if (readbackBuffer == nullptr) {
+    return false;
+  }
+  return readbackBuffer->gpuBuffer()->isReady();
+}
+
+const void* SurfaceReadback::lockPixels(Context* context, bool flipY) {
+  if (context != proxy->getContext()) {
+    LOGE("SurfaceReadback::lockPixels() Context mismatch!");
+    return nullptr;
+  }
+  if (locked) {
+    LOGE("SurfaceReadback::lockPixels() you must call unlockPixels() before locking again!");
+    return nullptr;
+  }
+  auto readbackBuffer = proxy->getBuffer();
+  if (readbackBuffer == nullptr) {
+    // The readback buffer has not been created yet because the transfer task has not been flushed.
+    // Flush all pending drawing and transfer commands, then wait for GPU completion. We must pass
+    // syncCpu=true because the GPU copy-to-buffer command needs to finish before we can map the
+    // buffer and read valid pixel data on the CPU side.
+    //
+    // Why this is necessary across all backends:
+    //   - Vulkan: submit() is async (fence-based), GPU may still be executing the transfer.
+    //   - Metal:  [cmd commit] is async, GPU blit may not have finished yet.
+    //   - OpenGL: glReadPixels is internally synchronous so this is redundant but harmless.
+    //   - DX12:   ExecuteCommandLists is async, same as Vulkan — must fence before Map().
+    context->flushAndSubmit(true);
+    readbackBuffer = proxy->getBuffer();
+    if (readbackBuffer == nullptr) {
+      LOGE("SurfaceReadback::lockPixels() Failed to get readback buffer!");
+      return nullptr;
+    }
+  } else {
+    // The buffer already exists (transfer task was flushed in a previous submit), but under
+    // asynchronous submission models the GPU transfer command may still be in-flight. We must
+    // wait for all previously submitted GPU work to complete before mapping the buffer.
+    //
+    // Without this wait, map() would return a pointer to memory that the GPU has not yet written
+    // to, resulting in stale or garbage pixel data (observed as test failures on Vulkan).
+    context->gpu()->queue()->waitUntilCompleted();
+  }
+  auto gpuBuffer = readbackBuffer->gpuBuffer();
+  // For async-only backends like WebGPU, trigger async mapping if not already started.
+  // With Asyncify enabled, requestMapAsync() will suspend the WASM stack when buffer.mapAsync()
+  // awaits, allowing the JS event loop to process the async operation and resume when complete.
+  if (!gpuBuffer->isReady()) {
+    gpuBuffer->requestMapAsync();
+    if (!gpuBuffer->isReady()) {
+      LOGE("SurfaceReadback::lockPixels() buffer mapping failed!");
+      return nullptr;
+    }
+  }
+  auto pixels = gpuBuffer->map();
+  if (pixels == nullptr) {
+    return nullptr;
+  }
+  if (flipY) {
+    flipYPixels = malloc(_info.byteSize());
+    if (flipYPixels == nullptr) {
+      readbackBuffer->gpuBuffer()->unmap();
+      return nullptr;
+    }
+    CopyPixels(_info, pixels, _info, flipYPixels, true);
+    pixels = flipYPixels;
+  }
+  locked = true;
+  return pixels;
+}
+
+void SurfaceReadback::unlockPixels(Context* context) {
+  if (context != proxy->getContext()) {
+    LOGE("SurfaceReadback::unlockPixels() Context mismatch!");
+    return;
+  }
+  if (!locked) {
+    return;
+  }
+  locked = false;
+  if (flipYPixels != nullptr) {
+    free(flipYPixels);
+    flipYPixels = nullptr;
+  }
+  auto readbackBuffer = proxy->getBuffer();
+  DEBUG_ASSERT(readbackBuffer != nullptr);
+  readbackBuffer->gpuBuffer()->unmap();
+}
+
+std::shared_ptr<GPUBuffer> SurfaceReadback::getGPUBuffer(Context* context) const {
+  if (context != proxy->getContext()) {
+    LOGE("SurfaceReadback::getGPUBuffer() Context mismatch!");
+    return nullptr;
+  }
+  auto readbackBuffer = proxy->getBuffer();
+  if (readbackBuffer == nullptr) {
+    context->flushAndSubmit(false);
+    readbackBuffer = proxy->getBuffer();
+    if (readbackBuffer == nullptr) {
+      return nullptr;
+    }
+  }
+  return readbackBuffer->gpuBuffer();
+}
+}  // namespace tgfx