[Impeller] Use minimal coverage for stencil restores after overdraw prevention (#39358)

bdero · web-flow · commit 67d35267c37c · 2023-02-03T00:47:36.000-08:00
diff --git a/impeller/entity/contents/clip_contents.cc b/impeller/entity/contents/clip_contents.cc
@@ -136,6 +136,11 @@ ClipRestoreContents::ClipRestoreContents() = default;
 
 ClipRestoreContents::~ClipRestoreContents() = default;
 
+void ClipRestoreContents::SetRestoreCoverage(
+    std::optional<Rect> restore_coverage) {
+  restore_coverage_ = restore_coverage;
+}
+
 std::optional<Rect> ClipRestoreContents::GetCoverage(
     const Entity& entity) const {
   return std::nullopt;
@@ -164,19 +169,20 @@ bool ClipRestoreContents::Render(const ContentContext& renderer,
   auto options = OptionsFromPassAndEntity(pass, entity);
   options.stencil_compare = CompareFunction::kLess;
   options.stencil_operation = StencilOperation::kSetToReferenceValue;
+  options.primitive_type = PrimitiveType::kTriangleStrip;
   cmd.pipeline = renderer.GetClipPipeline(options);
   cmd.stencil_reference = entity.GetStencilDepth();
 
-  // Create a rect that covers the whole render target.
-  auto size = pass.GetRenderTargetSize();
+  // Create a rect that covers either the given restore area, or the whole
+  // render target texture.
+  auto ltrb = restore_coverage_.value_or(Rect(Size(pass.GetRenderTargetSize())))
+                  .GetLTRB();
   VertexBufferBuilder<VS::PerVertexData> vtx_builder;
   vtx_builder.AddVertices({
-      {Point(0.0, 0.0)},
-      {Point(size.width, 0.0)},
-      {Point(size.width, size.height)},
-      {Point(0.0, 0.0)},
-      {Point(size.width, size.height)},
-      {Point(0.0, size.height)},
+      {Point(ltrb[0], ltrb[1])},
+      {Point(ltrb[2], ltrb[1])},
+      {Point(ltrb[0], ltrb[3])},
+      {Point(ltrb[2], ltrb[3])},
   });
   cmd.BindVertices(vtx_builder.CreateVertexBuffer(pass.GetTransientsBuffer()));
 
diff --git a/impeller/entity/contents/clip_contents.h b/impeller/entity/contents/clip_contents.h
@@ -55,6 +55,12 @@ class ClipRestoreContents final : public Contents {
 
   ~ClipRestoreContents();
 
+  /// @brief  The area on the pass texture where this clip restore will be
+  ///         applied. If unset, the entire pass texture will be restored.
+  ///
+  /// @note   This rectangle is not transformed by the entity's transformation.
+  void SetRestoreCoverage(std::optional<Rect> coverage);
+
   // |Contents|
   std::optional<Rect> GetCoverage(const Entity& entity) const override;
 
@@ -73,6 +79,8 @@ class ClipRestoreContents final : public Contents {
               RenderPass& pass) const override;
 
  private:
+  std::optional<Rect> restore_coverage_;
+
   FML_DISALLOW_COPY_AND_ASSIGN(ClipRestoreContents);
 };
 
diff --git a/impeller/entity/contents/linear_gradient_contents.cc b/impeller/entity/contents/linear_gradient_contents.cc
@@ -111,7 +111,9 @@ bool LinearGradientContents::RenderTexture(const ContentContext& renderer,
   }
 
   if (geometry_result.prevent_overdraw) {
-    return ClipRestoreContents().Render(renderer, entity, pass);
+    auto restore = ClipRestoreContents();
+    restore.SetRestoreCoverage(GetCoverage(entity));
+    return restore.Render(renderer, entity, pass);
   }
   return true;
 }
@@ -165,7 +167,9 @@ bool LinearGradientContents::RenderSSBO(const ContentContext& renderer,
   }
 
   if (geometry_result.prevent_overdraw) {
-    return ClipRestoreContents().Render(renderer, entity, pass);
+    auto restore = ClipRestoreContents();
+    restore.SetRestoreCoverage(GetCoverage(entity));
+    return restore.Render(renderer, entity, pass);
   }
   return true;
 }
diff --git a/impeller/entity/contents/radial_gradient_contents.cc b/impeller/entity/contents/radial_gradient_contents.cc
@@ -103,7 +103,9 @@ bool RadialGradientContents::RenderSSBO(const ContentContext& renderer,
   }
 
   if (geometry_result.prevent_overdraw) {
-    return ClipRestoreContents().Render(renderer, entity, pass);
+    auto restore = ClipRestoreContents();
+    restore.SetRestoreCoverage(GetCoverage(entity));
+    return restore.Render(renderer, entity, pass);
   }
   return true;
 }
@@ -166,7 +168,9 @@ bool RadialGradientContents::RenderTexture(const ContentContext& renderer,
   }
 
   if (geometry_result.prevent_overdraw) {
-    return ClipRestoreContents().Render(renderer, entity, pass);
+    auto restore = ClipRestoreContents();
+    restore.SetRestoreCoverage(GetCoverage(entity));
+    return restore.Render(renderer, entity, pass);
   }
   return true;
 }
diff --git a/impeller/entity/contents/runtime_effect_contents.cc b/impeller/entity/contents/runtime_effect_contents.cc
@@ -238,7 +238,9 @@ bool RuntimeEffectContents::Render(const ContentContext& renderer,
   pass.AddCommand(std::move(cmd));
 
   if (geometry_result.prevent_overdraw) {
-    return ClipRestoreContents().Render(renderer, entity, pass);
+    auto restore = ClipRestoreContents();
+    restore.SetRestoreCoverage(GetCoverage(entity));
+    return restore.Render(renderer, entity, pass);
   }
   return true;
 }
diff --git a/impeller/entity/contents/solid_color_contents.cc b/impeller/entity/contents/solid_color_contents.cc
@@ -83,7 +83,9 @@ bool SolidColorContents::Render(const ContentContext& renderer,
   }
 
   if (geometry_result.prevent_overdraw) {
-    return ClipRestoreContents().Render(renderer, entity, pass);
+    auto restore = ClipRestoreContents();
+    restore.SetRestoreCoverage(GetCoverage(entity));
+    return restore.Render(renderer, entity, pass);
   }
   return true;
 }
diff --git a/impeller/entity/contents/sweep_gradient_contents.cc b/impeller/entity/contents/sweep_gradient_contents.cc
@@ -109,7 +109,9 @@ bool SweepGradientContents::RenderSSBO(const ContentContext& renderer,
   }
 
   if (geometry_result.prevent_overdraw) {
-    return ClipRestoreContents().Render(renderer, entity, pass);
+    auto restore = ClipRestoreContents();
+    restore.SetRestoreCoverage(GetCoverage(entity));
+    return restore.Render(renderer, entity, pass);
   }
   return true;
 }
@@ -173,7 +175,9 @@ bool SweepGradientContents::RenderTexture(const ContentContext& renderer,
   }
 
   if (geometry_result.prevent_overdraw) {
-    return ClipRestoreContents().Render(renderer, entity, pass);
+    auto restore = ClipRestoreContents();
+    restore.SetRestoreCoverage(GetCoverage(entity));
+    return restore.Render(renderer, entity, pass);
   }
   return true;
 }
diff --git a/impeller/entity/contents/tiled_texture_contents.cc b/impeller/entity/contents/tiled_texture_contents.cc
@@ -96,7 +96,9 @@ bool TiledTextureContents::Render(const ContentContext& renderer,
   }
 
   if (geometry_result.prevent_overdraw) {
-    return ClipRestoreContents().Render(renderer, entity, pass);
+    auto restore = ClipRestoreContents();
+    restore.SetRestoreCoverage(GetCoverage(entity));
+    return restore.Render(renderer, entity, pass);
   }
   return true;
 }

Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,9 @@ bool LinearGradientContents::RenderTexture(const ContentContext& renderer,`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`if (geometry_result.prevent_overdraw) {`
`114`		`- return ClipRestoreContents().Render(renderer, entity, pass);`
	`114`	`+ auto restore = ClipRestoreContents();`
	`115`	`+ restore.SetRestoreCoverage(GetCoverage(entity));`
	`116`	`+ return restore.Render(renderer, entity, pass);`
`115`	`117`	`}`
`116`	`118`	`return true;`
`117`	`119`	`}`
`@@ -165,7 +167,9 @@ bool LinearGradientContents::RenderSSBO(const ContentContext& renderer,`
`165`	`167`	`}`
`166`	`168`
`167`	`169`	`if (geometry_result.prevent_overdraw) {`
`168`		`- return ClipRestoreContents().Render(renderer, entity, pass);`
	`170`	`+ auto restore = ClipRestoreContents();`
	`171`	`+ restore.SetRestoreCoverage(GetCoverage(entity));`
	`172`	`+ return restore.Render(renderer, entity, pass);`
`169`	`173`	`}`
`170`	`174`	`return true;`
`171`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,9 @@ bool RadialGradientContents::RenderSSBO(const ContentContext& renderer,`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`if (geometry_result.prevent_overdraw) {`
`106`		`- return ClipRestoreContents().Render(renderer, entity, pass);`
	`106`	`+ auto restore = ClipRestoreContents();`
	`107`	`+ restore.SetRestoreCoverage(GetCoverage(entity));`
	`108`	`+ return restore.Render(renderer, entity, pass);`
`107`	`109`	`}`
`108`	`110`	`return true;`
`109`	`111`	`}`
`@@ -166,7 +168,9 @@ bool RadialGradientContents::RenderTexture(const ContentContext& renderer,`
`166`	`168`	`}`
`167`	`169`
`168`	`170`	`if (geometry_result.prevent_overdraw) {`
`169`		`- return ClipRestoreContents().Render(renderer, entity, pass);`
	`171`	`+ auto restore = ClipRestoreContents();`
	`172`	`+ restore.SetRestoreCoverage(GetCoverage(entity));`
	`173`	`+ return restore.Render(renderer, entity, pass);`
`170`	`174`	`}`
`171`	`175`	`return true;`
`172`	`176`	`}`
Original file line number	Diff line number	Diff line change
`@@ -238,7 +238,9 @@ bool RuntimeEffectContents::Render(const ContentContext& renderer,`
`238`	`238`	`pass.AddCommand(std::move(cmd));`
`239`	`239`
`240`	`240`	`if (geometry_result.prevent_overdraw) {`
`241`		`- return ClipRestoreContents().Render(renderer, entity, pass);`
	`241`	`+ auto restore = ClipRestoreContents();`
	`242`	`+ restore.SetRestoreCoverage(GetCoverage(entity));`
	`243`	`+ return restore.Render(renderer, entity, pass);`
`242`	`244`	`}`
`243`	`245`	`return true;`
`244`	`246`	`}`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,9 @@ bool SolidColorContents::Render(const ContentContext& renderer,`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`if (geometry_result.prevent_overdraw) {`
`86`		`- return ClipRestoreContents().Render(renderer, entity, pass);`
	`86`	`+ auto restore = ClipRestoreContents();`
	`87`	`+ restore.SetRestoreCoverage(GetCoverage(entity));`
	`88`	`+ return restore.Render(renderer, entity, pass);`
`87`	`89`	`}`
`88`	`90`	`return true;`
`89`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,9 @@ bool SweepGradientContents::RenderSSBO(const ContentContext& renderer,`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`if (geometry_result.prevent_overdraw) {`
`112`		`- return ClipRestoreContents().Render(renderer, entity, pass);`
	`112`	`+ auto restore = ClipRestoreContents();`
	`113`	`+ restore.SetRestoreCoverage(GetCoverage(entity));`
	`114`	`+ return restore.Render(renderer, entity, pass);`
`113`	`115`	`}`
`114`	`116`	`return true;`
`115`	`117`	`}`
`@@ -173,7 +175,9 @@ bool SweepGradientContents::RenderTexture(const ContentContext& renderer,`
`173`	`175`	`}`
`174`	`176`
`175`	`177`	`if (geometry_result.prevent_overdraw) {`
`176`		`- return ClipRestoreContents().Render(renderer, entity, pass);`
	`178`	`+ auto restore = ClipRestoreContents();`
	`179`	`+ restore.SetRestoreCoverage(GetCoverage(entity));`
	`180`	`+ return restore.Render(renderer, entity, pass);`
`177`	`181`	`}`
`178`	`182`	`return true;`
`179`	`183`	`}`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,9 @@ bool TiledTextureContents::Render(const ContentContext& renderer,`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`if (geometry_result.prevent_overdraw) {`
`99`		`- return ClipRestoreContents().Render(renderer, entity, pass);`
	`99`	`+ auto restore = ClipRestoreContents();`
	`100`	`+ restore.SetRestoreCoverage(GetCoverage(entity));`
	`101`	`+ return restore.Render(renderer, entity, pass);`
`100`	`102`	`}`
`101`	`103`	`return true;`
`102`	`104`	`}`