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

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

@@ -0,0 +1,86 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 <string>
+
+namespace tgfx {
+
+class AdvancedTypefaceInfo {
+ public:
+  /**
+   * PostScript name.
+   */
+  std::string postScriptName;
+  /**
+   * Font type.
+   */
+  enum class FontType {
+    Type1,
+    Type1CID,
+    CFF,
+    TrueType,
+    Other,
+  };
+  FontType type = FontType::Other;
+
+  /**
+   * Font Descriptor Flags, aligned with the PDF specification's fontDescriptorFlags property.
+   */
+  enum StyleFlags {
+    // All characters in the font have the same width.
+    FixedPitch = 0x00000001,
+    // The font is a serif font (e.g., Times New Roman).
+    Serif = 0x00000002,
+    // The font is a symbolic font (e.g., Wingdings).
+    Symbolic = 0x00000004,
+    // The font is italic.
+    Italic = 0x00000040,
+    // The font uses all uppercase letters.
+    AllCaps = 0x00010000,
+    // The font uses small capital letters.
+    SmallCaps = 0x00020000,
+    // Forces bold display even if the font is not marked as bold.
+    ForceBold = 0x00040000
+  };
+  StyleFlags style = static_cast<StyleFlags>(0);
+
+  /**
+   * Font flags.
+   * Whether the font can be embedded and subset in the file during PDF export depends on these flags.
+   */
+  enum FontFlags {
+    // May be true for Type1, CFF, or TrueType fonts.
+    Variable = 1 << 0,
+    // May not be embedded.
+    NotEmbeddable = 1 << 1,
+    // May not be subset.
+    NotSubsettable = 1 << 2,
+    // Data compressed. Table access may still work.
+    AltDataFormat = 1 << 3,
+  };
+  FontFlags flags = static_cast<FontFlags>(0);
+
+  /**
+   * Height of an upper-case letter.
+   */
+  float capHeight = 0.f;
+};
+
+}  // namespace tgfx

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

@@ -0,0 +1,262 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "Atlas.h"
+#include "core/PixelRef.h"
+#include "core/utils/PixelFormatUtil.h"
+#include "gpu/DrawingManager.h"
+#include "gpu/ProxyProvider.h"
+namespace tgfx {
+
+static constexpr uint32_t PlotRecentlyUsedCount = 32;
+static constexpr uint32_t AtlasRecentlyUsedCount = 128;
+
+std::unique_ptr<Atlas> Atlas::Make(ProxyProvider* proxyProvider, PixelFormat pixelFormat, int width,
+                                   int height, int plotWidth, int plotHeight,
+                                   AtlasGenerationCounter* generationCounter) {
+  return std::unique_ptr<Atlas>(new Atlas(proxyProvider, pixelFormat, width, height, plotWidth,
+                                          plotHeight, generationCounter));
+}
+
+Atlas::Atlas(ProxyProvider* proxyProvider, PixelFormat pixelFormat, int width, int height,
+             int plotWidth, int plotHeight, AtlasGenerationCounter* generationCounter)
+    : proxyProvider(proxyProvider), pixelFormat(pixelFormat), generationCounter(generationCounter),
+      textureWidth(width), textureHeight(height), plotWidth(plotWidth), plotHeight(plotHeight) {
+  int numPlotX = width / plotWidth;
+  int numPlotY = height / plotHeight;
+  DEBUG_ASSERT(plotWidth * numPlotX == textureWidth);
+  DEBUG_ASSERT(plotHeight * numPlotY == textureHeight);
+  numPlots = static_cast<uint32_t>(numPlotX * numPlotY);
+}
+
+bool Atlas::addToAtlas(const AtlasCell& cell, AtlasToken nextFlushToken,
+                       AtlasLocator* atlasLocator) {
+  for (size_t pageIndex = 0; pageIndex < pages.size(); ++pageIndex) {
+    if (addToPage(cell, pageIndex, atlasLocator)) {
+      return true;
+    }
+  }
+  auto pageCount = pages.size();
+  if (pageCount == PlotLocator::MaxResidentPages) {
+    for (size_t pageIndex = 0; pageIndex < pageCount; ++pageIndex) {
+      Plot* plot = pages[pageIndex].plotList.back();
+      DEBUG_ASSERT(plot != nullptr);
+      if (plot->lastUseToken() < nextFlushToken) {
+        evictionPlot(plot);
+        if (plot->addRect(cell.width, cell.height, atlasLocator)) {
+          return true;
+        }
+        return false;
+      }
+    }
+  }
+  activateNewPage();
+  if (!addToPage(cell, pages.size() - 1, atlasLocator)) {
+    return false;
+  }
+  return true;
+}
+
+bool Atlas::addToPage(const AtlasCell& cell, size_t pageIndex, AtlasLocator* atlasLocator) {
+  auto& page = pages[pageIndex];
+  auto& plotList = page.plotList;
+  for (auto& plot : plotList) {
+    if (plot->addRect(cell.width, cell.height, atlasLocator)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool Atlas::activateNewPage() {
+  int numPlotX = textureWidth / plotWidth;
+  int numPlotY = textureHeight / plotHeight;
+  Page page;
+  page.plotArray =
+      std::make_unique<std::unique_ptr<Plot>[]>(static_cast<size_t>(numPlotX * numPlotY));
+  auto pageIndex = static_cast<uint32_t>(pages.size());
+  auto currentPlot = page.plotArray.get();
+  for (int y = numPlotY - 1, r = 0; y >= 0; --y, ++r) {
+    for (int x = numPlotX - 1, c = 0; x >= 0; --x, ++c) {
+      auto plotIndex = static_cast<uint32_t>(r * numPlotX + c);
+      *currentPlot = std::make_unique<Plot>(pageIndex, plotIndex, generationCounter, x, y,
+                                            plotWidth, plotHeight);
+      page.plotList.push_front(currentPlot->get());
+      ++currentPlot;
+    }
+  }
+  pages.push_back(std::move(page));
+  std::shared_ptr<TextureProxy> proxy = nullptr;
+  auto hardwareBuffer =
+      HardwareBufferAllocate(textureWidth, textureHeight, pixelFormat == PixelFormat::ALPHA_8);
+  if (hardwareBuffer != nullptr) {
+    proxy = proxyProvider->createTextureProxy(hardwareBuffer);
+    HardwareBufferRelease(hardwareBuffer);
+  }
+  if (proxy == nullptr) {
+    proxy = proxyProvider->createTextureProxy({}, textureWidth, textureHeight, pixelFormat);
+  }
+  if (proxy == nullptr) {
+    return false;
+  }
+  textureProxies.push_back(std::move(proxy));
+  return true;
+}
+
+bool Atlas::hasCell(const PlotLocator& plotLocator) const {
+  if (!plotLocator.isValid()) {
+    return false;
+  }
+  auto page = plotLocator.pageIndex();
+  auto plot = plotLocator.plotIndex();
+  if (page >= pages.size() || plot >= numPlots) {
+    return false;
+  }
+  auto plotGeneration = pages[page].plotArray[plot]->genID();
+  auto locatorGeneration = plotLocator.genID();
+  return plotGeneration == locatorGeneration;
+}
+
+void Atlas::setLastUseToken(const PlotLocator& plotLocator, AtlasToken token) {
+  auto plotIndex = plotLocator.plotIndex();
+  DEBUG_ASSERT(plotIndex < numPlots);
+  auto pageIndex = plotLocator.pageIndex();
+  DEBUG_ASSERT(pageIndex < pages.size());
+  auto plot = pages[pageIndex].plotArray[plotIndex].get();
+  DEBUG_ASSERT(plot != nullptr);
+  makeMRU(plot, pageIndex);
+  plot->setLastUseToken(token);
+}
+
+void Atlas::makeMRU(Plot* plot, uint32_t pageIndex) {
+  if (pages[pageIndex].plotList.front() == plot) {
+    return;
+  }
+  auto& plotList = pages[pageIndex].plotList;
+  if (auto iter = std::find(plotList.begin(), plotList.end(), plot); iter != plotList.end()) {
+    plotList.splice(plotList.begin(), plotList, iter);
+  }
+}
+
+void Atlas::evictionPlot(Plot* plot) {
+  plot->resetRects();
+}
+
+void Atlas::deactivateLastPage() {
+  DEBUG_ASSERT(!pages.empty());
+  pages.pop_back();
+  textureProxies.pop_back();
+}
+
+void Atlas::compact(AtlasToken startTokenForNextFlush) {
+  if (pages.empty()) {
+    previousFlushToken = startTokenForNextFlush;
+    return;
+  }
+
+  // For all plots, reset number of flushes if used this frame.
+  bool atlasUsedThisFlush = false;
+  for (auto& page : pages) {
+    for (auto& plot : page.plotList) {
+      //Reset number of flushes since used
+      if (plot->lastUseToken().isInterval(previousFlushToken, startTokenForNextFlush)) {
+        plot->resetFlushesSinceLastUsed();
+        atlasUsedThisFlush = true;
+      }
+    }
+  }
+  if (atlasUsedThisFlush) {
+    flushesSinceLastUse = 0;
+  } else {
+    ++flushesSinceLastUse;
+  }
+
+  // Compact if the atlas was used in the recently completed flush or
+  // hasn't been used in a long time.
+  if (atlasUsedThisFlush || flushesSinceLastUse > AtlasRecentlyUsedCount) {
+    std::vector<Plot*> availablePlots;
+    auto lastPageIndex = pages.size() - 1;
+    for (uint32_t pageIndex = 0; pageIndex < lastPageIndex; ++pageIndex) {
+      for (auto& plot : pages[pageIndex].plotList) {
+        if (!plot->lastUseToken().isInterval(previousFlushToken, startTokenForNextFlush)) {
+          plot->increaseFlushesSinceLastUsed();
+        }
+        if (plot->flushesSinceLastUsed() > PlotRecentlyUsedCount) {
+          availablePlots.push_back(plot);
+        }
+      }
+    }
+
+    //Check last page and evict any that are no longer in use
+    uint32_t usedPlots = 0;
+    for (auto& plot : pages[lastPageIndex].plotList) {
+      if (!plot->lastUseToken().isInterval(previousFlushToken, startTokenForNextFlush)) {
+        plot->increaseFlushesSinceLastUsed();
+      }
+      if (plot->flushesSinceLastUsed() <= PlotRecentlyUsedCount) {
+        ++usedPlots;
+      } else if (plot->lastUseToken() != AtlasToken::InvalidToken()) {
+        evictionPlot(plot);
+      }
+    }
+
+    // Evict a plot from the last page, and the availablePlots is also reduced by one,
+    // which is equivalent to moving a plot from the last page to a previous page
+    if (!availablePlots.empty() && usedPlots > 0 && usedPlots < numPlots / 4) {
+      for (auto& plot : pages[lastPageIndex].plotList) {
+        if (plot->flushesSinceLastUsed() > PlotRecentlyUsedCount) {
+          continue;
+        }
+
+        if (!availablePlots.empty()) {
+          evictionPlot(plot);
+          evictionPlot(availablePlots.back());
+          --usedPlots;
+          availablePlots.pop_back();
+        }
+        if (usedPlots == 0 || availablePlots.empty()) {
+          break;
+        }
+      }
+    }  //end if
+
+    //All plot can be moved to previous page, so we can deactivate the last page
+    if (usedPlots == 0) {
+      deactivateLastPage();
+      flushesSinceLastUse = 0;
+    }
+  }
+  previousFlushToken = startTokenForNextFlush;
+}
+
+AtlasConfig::AtlasConfig(int maxTextureSize) {
+  A8Dimensions.set(std::min(MaxAtlasSize, maxTextureSize), std::min(MaxAtlasSize, maxTextureSize));
+}
+
+ISize AtlasConfig::atlasDimensions(MaskFormat maskFormat) const {
+  if (maskFormat == MaskFormat::A8) {
+    return A8Dimensions;
+  }
+  return {A8Dimensions.width, A8Dimensions.height / 2};
+}
+
+ISize AtlasConfig::PlotDimensions() {
+  static ISize dimensions{PlotSize, PlotSize};
+  return dimensions;
+}
+}  // namespace tgfx

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

@@ -0,0 +1,95 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 <memory>
+#include "core/AtlasTypes.h"
+#include "gpu/ProxyProvider.h"
+#include "gpu/proxies/TextureProxy.h"
+#include "tgfx/core/Size.h"
+
+namespace tgfx {
+class Atlas {
+ public:
+  static constexpr int MaxCellSize = 256;
+
+  static std::unique_ptr<Atlas> Make(ProxyProvider* proxyProvider, PixelFormat format, int width,
+                                     int height, int plotWidth, int plotHeight,
+                                     AtlasGenerationCounter* generationCounter);
+
+  bool addToAtlas(const AtlasCell& cell, AtlasToken nextFlushToken, AtlasLocator* atlasLocator);
+
+  bool hasCell(const PlotLocator& plotLocator) const;
+
+  const std::vector<std::shared_ptr<TextureProxy>>& getTextureProxies() const {
+    return textureProxies;
+  }
+
+  void compact(AtlasToken);
+
+  //To ensure the atlas does not evict a given entry, the client must set the use token
+  void setLastUseToken(const PlotLocator& plotLocator, AtlasToken token);
+
+ private:
+  Atlas(ProxyProvider* proxyProvider, PixelFormat pixelFormat, int width, int height, int plotWidth,
+        int plotHeight, AtlasGenerationCounter* generationCounter);
+
+  void makeMRU(Plot* plot, uint32_t pageIndex);
+
+  bool activateNewPage();
+
+  bool addToPage(const AtlasCell& cell, size_t pageIndex, AtlasLocator* atlasLocator);
+
+  void evictionPlot(Plot* plot);
+
+  void deactivateLastPage();
+
+  struct Page {
+    std::unique_ptr<std::unique_ptr<Plot>[]> plotArray;
+    PlotList plotList;
+  };
+
+  ProxyProvider* proxyProvider = nullptr;
+  PixelFormat pixelFormat = PixelFormat::Unknown;
+  AtlasGenerationCounter* const generationCounter;
+  std::vector<std::shared_ptr<TextureProxy>> textureProxies = {};
+  std::vector<Page> pages = {};
+  AtlasToken previousFlushToken = AtlasToken::InvalidToken();
+  uint32_t flushesSinceLastUse = 0;
+  uint32_t numPlots = 0;
+  int textureWidth = 2028;
+  int textureHeight = 2048;
+  int plotWidth = 512;
+  int plotHeight = 512;
+};
+
+class AtlasConfig {
+ public:
+  explicit AtlasConfig(int maxTextureSize);
+
+  ISize atlasDimensions(MaskFormat maskFormat) const;
+
+  static ISize PlotDimensions();
+
+ private:
+  static constexpr int MaxAtlasSize = 2048;
+  static constexpr int PlotSize = 512;
+  ISize A8Dimensions = {MaxAtlasSize, MaxAtlasSize};
+};
+}  // namespace tgfx

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

@@ -0,0 +1,99 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 "AtlasManager.h"
+#include "core/utils/PixelFormatUtil.h"
+#include "tgfx/core/Size.h"
+
+namespace tgfx {
+static int MaskFormatToAtlasIndex(MaskFormat format) {
+  return static_cast<int>(format);
+}
+
+AtlasManager::AtlasManager(Context* context) : context(context) {
+}
+
+const std::vector<std::shared_ptr<TextureProxy>>& AtlasManager::getTextureProxies(
+    MaskFormat maskFormat) {
+  if (this->initAtlas(maskFormat)) {
+    return this->getAtlas(maskFormat)->getTextureProxies();
+  }
+  static std::vector<std::shared_ptr<TextureProxy>> kEmpty;
+  return kEmpty;
+}
+
+bool AtlasManager::initAtlas(MaskFormat maskFormat) {
+  auto index = MaskFormatToAtlasIndex(maskFormat);
+  if (atlases[index] != nullptr) {
+    return true;
+  }
+  AtlasConfig atlasConfig(context->gpu()->limits()->maxTextureDimension2D);
+  ISize atlasDimensions = atlasConfig.atlasDimensions(maskFormat);
+  ISize plotDimensions = AtlasConfig::PlotDimensions();
+  auto pixelFormat = MaskFormatToPixelFormat(maskFormat);
+  atlases[index] =
+      Atlas::Make(context->proxyProvider(), pixelFormat, atlasDimensions.width,
+                  atlasDimensions.height, plotDimensions.width, plotDimensions.height, this);
+  if (atlases[index] == nullptr) {
+    return false;
+  }
+  return true;
+}
+
+Atlas* AtlasManager::getAtlas(MaskFormat maskFormat) const {
+  auto atlasIndex = MaskFormatToAtlasIndex(maskFormat);
+  DEBUG_ASSERT(atlases[atlasIndex] != nullptr)
+  return atlases[atlasIndex].get();
+}
+
+bool AtlasManager::addCellToAtlas(const AtlasCell& cell, AtlasToken nextFlushToken,
+                                  AtlasLocator* atlasLocator) const {
+  return getAtlas(cell.maskFormat)->addToAtlas(cell, nextFlushToken, atlasLocator);
+}
+
+bool AtlasManager::hasGlyph(MaskFormat maskFormat, const AtlasGlyph* glyph) const {
+  return this->getAtlas(maskFormat)->hasCell(glyph->atlasLocator.plotLocator());
+}
+
+void AtlasManager::setPlotUseToken(PlotUseUpdater& plotUseUpdater, const PlotLocator& plotLocator,
+                                   MaskFormat maskFormat, AtlasToken useToken) const {
+  if (plotUseUpdater.add(plotLocator)) {
+    getAtlas(maskFormat)->setLastUseToken(plotLocator, useToken);
+  }
+}
+
+void AtlasManager::postFlush() {
+  atlasTokenTracker.advanceToken();
+  for (const auto& atlas : atlases) {
+    if (atlas) {
+      atlas->compact(atlasTokenTracker.nextToken());
+    }
+  }
+}
+
+AtlasToken AtlasManager::nextFlushToken() const {
+  return atlasTokenTracker.nextToken();
+}
+
+void AtlasManager::releaseAll() {
+  for (auto& atlas : atlases) {
+    atlas = nullptr;
+  }
+}
+
+}  // namespace tgfx

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

@@ -0,0 +1,60 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 <memory>
+#include "Atlas.h"
+#include "AtlasTypes.h"
+
+namespace tgfx {
+class AtlasManager : public AtlasGenerationCounter {
+ public:
+  explicit AtlasManager(Context* context);
+
+  // This function must be called first, before other functions which use the atlas.
+  // if it returns empty, the client must not try to use other functions.
+  const std::vector<std::shared_ptr<TextureProxy>>& getTextureProxies(MaskFormat maskFormat);
+
+  bool hasGlyph(MaskFormat, const AtlasGlyph* glyph) const;
+
+  bool addCellToAtlas(const AtlasCell& cell, AtlasToken nextFlushToken, AtlasLocator*) const;
+
+  void setPlotUseToken(PlotUseUpdater&, const PlotLocator&, MaskFormat, AtlasToken) const;
+
+  void preFlush() {
+  }
+
+  void postFlush();
+
+  AtlasToken nextFlushToken() const;
+
+  // Releases all atlas resources,
+  // including their underlying textures.
+  void releaseAll();
+
+ private:
+  bool initAtlas(MaskFormat format);
+
+  Atlas* getAtlas(MaskFormat format) const;
+
+  Context* context = nullptr;
+  std::unique_ptr<Atlas> atlases[MaskFormatCount];
+  AtlasTokenTracker atlasTokenTracker = {};
+};
+}  // namespace tgfx