WIP: [impeller] Add tessellation cache

impeller/aiks/aiks_context.cc

@@ -5,6 +5,7 @@
 #include "impeller/aiks/aiks_context.h"
 
 #include "impeller/aiks/picture.h"
+#include "impeller/entity/contents/tessellation_cache.h"
 
 namespace impeller {
 
@@ -42,7 +43,11 @@ bool AiksContext::Render(const Picture& picture, RenderTarget& render_target) {
   }
 
   if (picture.pass) {
-    return picture.pass->Render(*content_context_, render_target);
+    auto res = picture.pass->Render(*content_context_, render_target);
+    // FIXME(knopp): This should be called for the last surface of the frame,
+    // but there's currently no way to do this.
+    content_context_->GetTessellationCache().FinishFrame();
+    return res;
   }
 
   return true;

impeller/aiks/canvas.cc

@@ -22,6 +22,11 @@
 
 namespace impeller {
 
+namespace {
+const uint32_t kTagDlRRect = 'dlrr';
+const uint32_t kTagDlCircle = 'dlci';
+}  // namespace
+
 Canvas::Canvas() {
   Initialize(std::nullopt);
 }
@@ -242,6 +247,11 @@ void Canvas::DrawRRect(Rect rect, Scalar corner_radius, const Paint& paint) {
                   .SetConvexity(Convexity::kConvex)
                   .AddRoundedRect(rect, corner_radius)
                   .TakePath();
+  struct {
+    Rect rect;
+    Scalar corner_radius;
+  } identifier = {.rect = rect, .corner_radius = corner_radius};
+  path.SetPathIdentifier(PathIdentifier(kTagDlRRect, identifier));
   if (paint.style == Paint::Style::kFill) {
     Entity entity;
     entity.SetTransformation(GetCurrentTransformation());
@@ -266,6 +276,11 @@ void Canvas::DrawCircle(Point center, Scalar radius, const Paint& paint) {
                          .AddCircle(center, radius)
                          .SetConvexity(Convexity::kConvex)
                          .TakePath();
+  struct {
+    Point center;
+    Scalar radius;
+  } identifier = {.center = center, .radius = radius};
+  circle_path.SetPathIdentifier(PathIdentifier(kTagDlCircle, identifier));
   DrawPath(circle_path, paint);
 }
 

impeller/display_list/dl_dispatcher.cc

@@ -889,10 +889,7 @@ void DlDispatcher::drawRRect(const SkRRect& rrect) {
 
 // |flutter::DlOpReceiver|
 void DlDispatcher::drawDRRect(const SkRRect& outer, const SkRRect& inner) {
-  PathBuilder builder;
-  builder.AddPath(skia_conversions::ToPath(outer));
-  builder.AddPath(skia_conversions::ToPath(inner));
-  canvas_.DrawPath(builder.TakePath(FillType::kOdd), paint_);
+  canvas_.DrawPath(skia_conversions::ToPath(outer, inner), paint_);
 }
 
 // |flutter::DlOpReceiver|

impeller/display_list/skia_conversions.cc

@@ -9,6 +9,12 @@
 namespace impeller {
 namespace skia_conversions {
 
+namespace {
+const uint32_t kTagSkiaPath = 'skpa';
+const uint32_t kTagSkiaRRect = 'skrr';
+const uint32_t kTagSkiaDRRect = 'skdr';
+}  // namespace
+
 Rect ToRect(const SkRect& rect) {
   return Rect::MakeLTRB(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
 }
@@ -121,14 +127,47 @@ Path ToPath(const SkPath& path) {
   }
   builder.SetConvexity(path.isConvex() ? Convexity::kConvex
                                        : Convexity::kUnknown);
-  return builder.TakePath(fill_type);
+  auto result = builder.TakePath(fill_type);
+  struct {
+    uint32_t generation_id;
+    FillType fill_type;
+  } identifier = {
+      .generation_id = path.getGenerationID(),
+      .fill_type = fill_type,
+  };
+  result.SetPathIdentifier(PathIdentifier(kTagSkiaPath, identifier));
+  return result;
 }
 
 Path ToPath(const SkRRect& rrect) {
-  return PathBuilder{}
-      .AddRoundedRect(ToRect(rrect.getBounds()), ToRoundingRadii(rrect))
-      .SetConvexity(Convexity::kConvex)
-      .TakePath();
+  auto path =
+      PathBuilder{}
+          .AddRoundedRect(ToRect(rrect.getBounds()), ToRoundingRadii(rrect))
+          .SetConvexity(Convexity::kConvex)
+          .TakePath();
+  struct {
+    SkRRect rrect;
+  } identifier = {
+      .rrect = rrect,
+  };
+  path.SetPathIdentifier(PathIdentifier(kTagSkiaRRect, identifier));
+  return path;
+}
+
+Path ToPath(const SkRRect& outer, const SkRRect& inner) {
+  PathBuilder builder;
+  builder.AddPath(ToPath(outer));
+  builder.AddPath(ToPath(inner));
+  auto path = builder.TakePath(FillType::kOdd);
+  struct {
+    SkRRect outer;
+    SkRRect inner;
+  } identifier = {
+      .outer = outer,
+      .inner = inner,
+  };
+  path.SetPathIdentifier(PathIdentifier(kTagSkiaDRRect, identifier));
+  return path;
 }
 
 Point ToPoint(const SkPoint& point) {

impeller/display_list/skia_conversions.h

@@ -42,6 +42,8 @@ Path ToPath(const SkPath& path);
 
 Path ToPath(const SkRRect& rrect);
 
+Path ToPath(const SkRRect& outer, const SkRRect& inner);
+
 Path PathDataFromTextBlob(const sk_sp<SkTextBlob>& blob);
 
 std::optional<impeller::PixelFormat> ToPixelFormat(SkColorType type);

impeller/entity/BUILD.gn

@@ -197,6 +197,8 @@ impeller_component("entity") {
     "contents/gradient_generator.h",
     "contents/linear_gradient_contents.cc",
     "contents/linear_gradient_contents.h",
+    "contents/tessellation_cache.cc",
+    "contents/tessellation_cache.h",
     "contents/radial_gradient_contents.cc",
     "contents/radial_gradient_contents.h",
     "contents/runtime_effect_contents.cc",
@@ -261,6 +263,10 @@ impeller_component("entity") {
     "../typographer",
   ]
 
+  cflags = [
+    "-g",
+  ]
+
   deps = [ "//flutter/fml" ]
 }
 

impeller/entity/contents/content_context.cc

@@ -9,6 +9,7 @@
 
 #include "impeller/base/strings.h"
 #include "impeller/core/formats.h"
+#include "impeller/entity/contents/tessellation_cache.h"
 #include "impeller/entity/entity.h"
 #include "impeller/renderer/command_buffer.h"
 #include "impeller/renderer/pipeline_library.h"
@@ -162,6 +163,7 @@ ContentContext::ContentContext(std::shared_ptr<Context> context)
     : context_(std::move(context)),
       lazy_glyph_atlas_(std::make_shared<LazyGlyphAtlas>()),
       tessellator_(std::make_shared<Tessellator>()),
+      tessellation_cache_(std::make_unique<TessellationCache>()),
       scene_context_(std::make_shared<scene::SceneContext>(context_)) {
   if (!context_ || !context_->IsValid()) {
     return;

impeller/entity/contents/content_context.h

@@ -329,6 +329,7 @@ struct ContentContextOptions {
 };
 
 class Tessellator;
+class TessellationCache;
 
 class ContentContext {
  public:
@@ -342,6 +343,10 @@ class ContentContext {
 
   std::shared_ptr<Tessellator> GetTessellator() const;
 
+  TessellationCache& GetTessellationCache() const {
+    return *tessellation_cache_;
+  }
+
 #ifdef IMPELLER_DEBUG
   std::shared_ptr<Pipeline<PipelineDescriptor>> GetCheckerboardPipeline(
       ContentContextOptions opts) const {
@@ -853,6 +858,7 @@ class ContentContext {
 
   bool is_valid_ = false;
   std::shared_ptr<Tessellator> tessellator_;
+  std::unique_ptr<TessellationCache> tessellation_cache_;
   std::shared_ptr<scene::SceneContext> scene_context_;
   bool wireframe_ = false;
 

impeller/entity/contents/tessellation_cache.cc

@@ -0,0 +1,70 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "impeller/entity/contents/tessellation_cache.h"
+
+#define IMPELLER_ENABLE_TESSELLATION_CACHE 1
+
+namespace impeller {
+
+Path::Polyline TessellationCache::GetOrCreatePolyline(
+    const impeller::Path& path,
+    Scalar scale) {
+#if IMPELLER_ENABLE_TESSELLATION_CACHE == 1
+  auto path_identifier = path.GetPathIdentifier();
+  if (!path_identifier) {
+    // We can't match path without a valid identifier.
+    return path.CreatePolyline(scale);
+  }
+  PolylineKey key{*path_identifier, scale};
+  auto result = polyline_cache_.Get(key);
+  if (result) {
+    return *result;
+  }
+  auto polyline = path.CreatePolyline(scale);
+  polyline_cache_.Set(key, polyline);
+  return polyline;
+#else
+  return path.CreatePolyline(scale);
+#endif
+}
+
+Tessellator::Result TessellationCache::Tessellate(
+    const Tessellator& tesselator,
+    FillType fill_type,
+    const Path::Polyline& polyline,
+    const Tessellator::BuilderCallback& callback) {
+#if IMPELLER_ENABLE_TESSELLATION_CACHE == 1
+  auto path_identifier = polyline.original_path_identifier;
+  if (!path_identifier) {
+    return tesselator.Tessellate(fill_type, polyline, callback);
+  }
+
+  TessellatorKey key{*path_identifier, fill_type};
+  auto result = tessellator_cache_.Get(key);
+  if (result) {
+    if (callback(result->vertices.data(), result->vertices.size(),
+                 result->indices.data(), result->indices.size())) {
+      return Tessellator::Result::kSuccess;
+    } else {
+      return Tessellator::Result::kInputError;
+    }
+  }
+
+  return tesselator.Tessellate(
+      fill_type, polyline,
+      [&](const float* vertices, size_t vertices_size, const uint16_t* indices,
+          size_t indices_size) {
+        TessellatorData data;
+        data.vertices.assign(vertices, vertices + vertices_size);
+        data.indices.assign(indices, indices + indices_size);
+        tessellator_cache_.Set(key, data);
+        return callback(vertices, vertices_size, indices, indices_size);
+      });
+#else
+  return tesselator.Tessellate(fill_type, polyline, callback);
+#endif
+}
+
+}  // namespace impeller