Remove the surface property from the RenderContext class. (#443)

include/tgfx/core/Canvas.h

@@ -421,12 +421,12 @@ class Canvas {
                  const Paint* paint = nullptr);
 
  private:
-  Surface* surface = nullptr;
   DrawContext* drawContext = nullptr;
+  Surface* surface = nullptr;
   std::unique_ptr<MCState> mcState;
   std::stack<std::unique_ptr<CanvasState>> stateStack;
 
-  explicit Canvas(DrawContext* drawContext);
+  explicit Canvas(DrawContext* drawContext, Surface* surface = nullptr);
   void drawClip(const FillStyle& style);
   void drawShape(std::shared_ptr<Shape> shape, const MCState& state, const FillStyle& style);
   void drawImage(std::shared_ptr<Image> image, const SamplingOptions& sampling, const Paint* paint,

include/tgfx/core/Surface.h

@@ -29,7 +29,6 @@ class Canvas;
 class Context;
 class RenderContext;
 class RenderTargetProxy;
-class TextureProxy;
 
 /**
  * The Surface class is responsible for managing the pixels that a Canvas draws into. The Surface
@@ -98,9 +97,7 @@ class Surface {
   /**
    * Returns the render flags associated with this Surface.
    */
-  uint32_t renderFlags() const {
-    return _renderFlags;
-  }
+  uint32_t renderFlags() const;
 
   /**
    * Returns the width of this surface.
@@ -183,20 +180,14 @@ class Surface {
   uint32_t contentVersion() const;
 
   uint32_t _uniqueID = 0;
-  std::shared_ptr<RenderTargetProxy> renderTargetProxy = nullptr;
-  uint32_t _renderFlags = 0;
   RenderContext* renderContext = nullptr;
   Canvas* canvas = nullptr;
-  std::shared_ptr<Image> cachedImage = nullptr;
 
   static std::shared_ptr<Surface> MakeFrom(std::shared_ptr<RenderTargetProxy> renderTargetProxy,
                                            uint32_t renderFlags = 0);
 
   Surface(std::shared_ptr<RenderTargetProxy> proxy, uint32_t renderFlags = 0);
 
-  bool aboutToDraw(const std::function<bool()>& willDiscardContent);
-
-  friend class RenderContext;
   friend class PictureImage;
   friend class DisplayList;
 };

src/core/Canvas.cpp

@@ -71,8 +71,8 @@ static FillStyle CreateFillStyle(const Paint* paint) {
   return paint ? CreateFillStyle(*paint) : FillStyle();
 }
 
-Canvas::Canvas(DrawContext* drawContext)
-    : surface(drawContext->getSurface()), drawContext(drawContext) {
+Canvas::Canvas(DrawContext* drawContext, Surface* surface)
+    : drawContext(drawContext), surface(surface) {
   mcState = std::make_unique<MCState>();
 }
 

src/core/DrawContext.h

@@ -35,13 +35,6 @@ class DrawContext {
  public:
   virtual ~DrawContext() = default;
 
-  /**
-   * Returns the associated Surface if the DrawContext is backed by one, otherwise returns nullptr.
-   */
-  virtual Surface* getSurface() const {
-    return nullptr;
-  }
-
   /**
    * Fills the entire clip area with the specified FillStyle.
    */

src/core/Picture.cpp

@@ -51,15 +51,7 @@ void Picture::playback(Canvas* canvas) const {
 
 void Picture::playback(DrawContext* drawContext, const MCState& state) const {
   DEBUG_ASSERT(drawContext != nullptr);
-  std::unique_ptr<TransformContext> transformContext;
-  auto surface = drawContext->getSurface();
-  Rect rect = {};
-  if (surface && state.clip.isRect(&rect) &&
-      rect == Rect::MakeWH(surface->width(), surface->height())) {
-    transformContext = TransformContext::Make(drawContext, state.matrix);
-  } else {
-    transformContext = TransformContext::Make(drawContext, state.matrix, state.clip);
-  }
+  auto transformContext = TransformContext::Make(drawContext, state.matrix, state.clip);
   if (transformContext) {
     drawContext = transformContext.get();
   } else if (state.clip.isEmpty() && !state.clip.isInverseFillType()) {

src/core/TransformContext.cpp

@@ -100,8 +100,7 @@ std::unique_ptr<TransformContext> TransformContext::Make(DrawContext* drawContex
   }
   if (matrix.isIdentity()) {
     return std::make_unique<ClipDrawContext>(drawContext, clip);
-  } else {
-    return std::make_unique<MCStateDrawContext>(drawContext, matrix, clip);
   }
+  return std::make_unique<MCStateDrawContext>(drawContext, matrix, clip);
 }
 }  // namespace tgfx

src/gpu/DrawingManager.cpp

@@ -25,10 +25,10 @@
 #include "gpu/tasks/TextureResolveTask.h"
 
 namespace tgfx {
-std::shared_ptr<OpsRenderTask> DrawingManager::addOpsTask(
-    std::shared_ptr<RenderTargetProxy> renderTargetProxy, uint32_t renderFlags) {
-  checkIfResolveNeeded(renderTargetProxy);
-  auto opsTask = std::make_shared<OpsRenderTask>(renderTargetProxy, renderFlags);
+std::shared_ptr<OpsRenderTask> DrawingManager::addOpsTask(std::shared_ptr<RenderTargetProxy> target,
+                                                          uint32_t renderFlags) {
+  checkIfResolveNeeded(target);
+  auto opsTask = std::make_shared<OpsRenderTask>(std::move(target), renderFlags);
   addRenderTask(opsTask);
   activeOpsTask = opsTask;
   return opsTask;
@@ -42,7 +42,8 @@ void DrawingManager::addRuntimeDrawTask(std::shared_ptr<RenderTargetProxy> targe
     return;
   }
   checkIfResolveNeeded(target);
-  auto task = std::make_shared<RuntimeDrawTask>(target, inputs, effect, offset);
+  auto task = std::make_shared<RuntimeDrawTask>(std::move(target), std::move(inputs),
+                                                std::move(effect), offset);
   addRenderTask(std::move(task));
 }
 
@@ -53,15 +54,14 @@ void DrawingManager::addTextureFlattenTask(std::shared_ptr<TextureFlattenTask> f
   flattenTasks.push_back(std::move(flattenTask));
 }
 
-void DrawingManager::addTextureResolveTask(std::shared_ptr<RenderTargetProxy> renderTargetProxy) {
-  auto textureProxy = renderTargetProxy->getTextureProxy();
-  if (textureProxy == nullptr ||
-      (renderTargetProxy->sampleCount() <= 1 && !textureProxy->hasMipmaps())) {
+void DrawingManager::addTextureResolveTask(std::shared_ptr<RenderTargetProxy> target) {
+  auto textureProxy = target->getTextureProxy();
+  if (textureProxy == nullptr || (target->sampleCount() <= 1 && !textureProxy->hasMipmaps())) {
     return;
   }
   // TODO(domchen): Skip resolving if the render target is not in the needResolveTargets set.
-  needResolveTargets.erase(renderTargetProxy);
-  auto task = std::make_shared<TextureResolveTask>(renderTargetProxy);
+  needResolveTargets.erase(target);
+  auto task = std::make_shared<TextureResolveTask>(std::move(target));
   addRenderTask(std::move(task));
 }
 
@@ -71,7 +71,8 @@ void DrawingManager::addRenderTargetCopyTask(std::shared_ptr<RenderTargetProxy>
   if (source == nullptr || dest == nullptr) {
     return;
   }
-  auto task = std::make_shared<RenderTargetCopyTask>(source, dest, srcRect, dstPoint);
+  auto task =
+      std::make_shared<RenderTargetCopyTask>(std::move(source), std::move(dest), srcRect, dstPoint);
   addRenderTask(std::move(task));
 }
 

src/gpu/OpContext.cpp

@@ -21,12 +21,9 @@
 #include "gpu/ops/RectDrawOp.h"
 
 namespace tgfx {
-static constexpr uint32_t InvalidContentVersion = 0;
-
 void OpContext::fillWithFP(std::unique_ptr<FragmentProcessor> fp, const Matrix& uvMatrix,
                            bool autoResolve) {
-  fillRectWithFP(Rect::MakeWH(renderTargetProxy->width(), renderTargetProxy->height()),
-                 std::move(fp), uvMatrix, autoResolve);
+  fillRectWithFP(bounds(), std::move(fp), uvMatrix, autoResolve);
 }
 
 void OpContext::fillRectWithFP(const Rect& dstRect, std::unique_ptr<FragmentProcessor> fp,
@@ -39,19 +36,23 @@ void OpContext::fillRectWithFP(const Rect& dstRect, std::unique_ptr<FragmentProc
   op->setBlendMode(BlendMode::Src);
   addOp(std::move(op));
   if (autoResolve) {
-    auto drawingManager = renderTargetProxy->getContext()->drawingManager();
-    drawingManager->addTextureResolveTask(renderTargetProxy);
+    auto drawingManager = renderTarget->getContext()->drawingManager();
+    drawingManager->addTextureResolveTask(renderTarget);
   }
 }
 
 void OpContext::addOp(std::unique_ptr<Op> op) {
   if (opsTask == nullptr || opsTask->isClosed()) {
-    auto drawingManager = renderTargetProxy->getContext()->drawingManager();
-    opsTask = drawingManager->addOpsTask(renderTargetProxy, renderFlags);
+    auto drawingManager = renderTarget->getContext()->drawingManager();
+    opsTask = drawingManager->addOpsTask(renderTarget, renderFlags);
   }
   opsTask->addOp(std::move(op));
-  do {
-    _contentVersion++;
-  } while (InvalidContentVersion == _contentVersion);
 }
+
+void OpContext::replaceRenderTarget(std::shared_ptr<RenderTargetProxy> newRenderTarget) {
+  DEBUG_ASSERT(newRenderTarget != nullptr);
+  opsTask = nullptr;
+  renderTarget = std::move(newRenderTarget);
+}
+
 }  // namespace tgfx

src/gpu/OpContext.h

@@ -28,12 +28,12 @@ namespace tgfx {
  */
 class OpContext {
  public:
-  explicit OpContext(std::shared_ptr<RenderTargetProxy> renderTargetProxy, uint32_t renderFlags)
-      : renderTargetProxy(std::move(renderTargetProxy)), renderFlags(renderFlags) {
+  explicit OpContext(std::shared_ptr<RenderTargetProxy> proxy, uint32_t renderFlags)
+      : renderTarget(std::move(proxy)), renderFlags(renderFlags) {
   }
 
-  RenderTargetProxy* renderTarget() const {
-    return renderTargetProxy.get();
+  Rect bounds() const {
+    return Rect::MakeWH(renderTarget->width(), renderTarget->height());
   }
 
   void fillWithFP(std::unique_ptr<FragmentProcessor> fp, const Matrix& uvMatrix,
@@ -44,14 +44,13 @@ class OpContext {
 
   void addOp(std::unique_ptr<Op> op);
 
-  uint32_t contentVersion() const {
-    return _contentVersion;
-  }
+  void replaceRenderTarget(std::shared_ptr<RenderTargetProxy> newRenderTarget);
 
  private:
-  std::shared_ptr<RenderTargetProxy> renderTargetProxy = nullptr;
-  std::shared_ptr<OpsRenderTask> opsTask = nullptr;
+  std::shared_ptr<RenderTargetProxy> renderTarget = nullptr;
   uint32_t renderFlags = 0;
-  uint32_t _contentVersion = 1u;
+  std::shared_ptr<OpsRenderTask> opsTask = nullptr;
+
+  friend class RenderContext;
 };
 }  // namespace tgfx