Method createGPUShapeProxy

src/gpu/ProxyProvider.cpp:148–224

}

std::shared_ptr<GPUShapeProxy> ProxyProvider::createGPUShapeProxy(std::shared_ptr<Shape> shape,
                                                                  AAType aaType,
                                                                  const Rect& clipBounds,
                                                                  uint32_t renderFlags) {
  if (shape == nullptr) {
    return nullptr;
  }
  Matrix drawingMatrix = {};
  auto isInverseFillType = shape->isInverseFillType();
  if (shape->type() == Shape::Type::Matrix && !isInverseFillType) {
    auto matrixShape = std::static_pointer_cast<MatrixShape>(shape);
    auto scales = matrixShape->matrix.getAxisScales();
    if (scales.x == scales.y) {
      DEBUG_ASSERT(scales.x != 0);
      drawingMatrix = matrixShape->matrix;
      drawingMatrix.preScale(1.0f / scales.x, 1.0f / scales.x);
      shape = Shape::ApplyMatrix(matrixShape->shape, Matrix::MakeScale(scales.x));
    }
  }
  auto shapeBounds = shape->getBounds();
  auto uniqueKey = shape->getUniqueKey();
  if (isInverseFillType) {
    uniqueKey =
        AppendClipBoundsKey(uniqueKey, clipBounds.makeOffset(-shapeBounds.left, -shapeBounds.top));
  }
  if (aaType != AAType::None) {
    // Add a 1-pixel outset to preserve antialiasing results.
    shapeBounds.outset(1.0f, 1.0f);
  } else {
    static const auto NonAntialiasShapeType = UniqueID::Next();
    uniqueKey = UniqueKey::Append(uniqueKey, &NonAntialiasShapeType, 1);
  }
  auto bounds = isInverseFillType ? clipBounds : shapeBounds;
  drawingMatrix.preTranslate(bounds.x(), bounds.y());
  static const auto TriangleShapeType = UniqueID::Next();
  static const auto TextureShapeType = UniqueID::Next();
  auto triangleKey = UniqueKey::Append(uniqueKey, &TriangleShapeType, 1);
  // The triangle and texture proxies might be created by previous tasks that are still in progress.
  // One of them might not have the corresponding resources in the cache yet, so we need to wrap
  // both of them into the GPUShapeProxy.
  auto triangleProxy = findOrWrapVertexBufferProxy(triangleKey);
  auto textureKey = UniqueKey::Append(uniqueKey, &TextureShapeType, 1);
  auto textureProxy = findOrWrapTextureProxy(textureKey);
  if (triangleProxy != nullptr || textureProxy != nullptr) {
    return std::make_shared<GPUShapeProxy>(drawingMatrix, std::move(triangleProxy),
                                           std::move(textureProxy));
  }
  auto width = static_cast<int>(ceilf(bounds.width()));
  auto height = static_cast<int>(ceilf(bounds.height()));
  shape = Shape::ApplyMatrix(std::move(shape), Matrix::MakeTrans(-bounds.x(), -bounds.y()));
  auto rasterizer = std::make_unique<ShapeRasterizer>(width, height, std::move(shape), aaType);
  std::unique_ptr<DataSource<ShapeBuffer>> dataSource = nullptr;
#ifdef TGFX_USE_THREADS
  if (!(renderFlags & RenderFlags::DisableAsyncTask) && rasterizer->asyncSupport()) {
    dataSource = DataSource<ShapeBuffer>::Async(std::move(rasterizer));
  } else {
    dataSource = std::move(rasterizer);
  }