Revert "[Impeller] SDF text rendering "

ci/licenses_golden/licenses_flutter

@@ -658,8 +658,6 @@ FILE: ../../../flutter/impeller/entity/shaders/gaussian_blur.frag
 FILE: ../../../flutter/impeller/entity/shaders/gaussian_blur.vert
 FILE: ../../../flutter/impeller/entity/shaders/glyph_atlas.frag
 FILE: ../../../flutter/impeller/entity/shaders/glyph_atlas.vert
-FILE: ../../../flutter/impeller/entity/shaders/glyph_atlas_sdf.frag
-FILE: ../../../flutter/impeller/entity/shaders/glyph_atlas_sdf.vert
 FILE: ../../../flutter/impeller/entity/shaders/gradient_fill.vert
 FILE: ../../../flutter/impeller/entity/shaders/linear_gradient_fill.frag
 FILE: ../../../flutter/impeller/entity/shaders/linear_to_srgb_filter.frag

impeller/compiler/shader_lib/impeller/transform.glsl

@@ -11,24 +11,4 @@ vec2 IPVec2TransformPosition(mat4 matrix, vec2 point) {
   return transformed.xy / transformed.w;
 }
 
-// Returns the transformed gl_Position for a given glyph position in a glyph
-// atlas.
-vec4 IPPositionForGlyphPosition(mat4 mvp, vec2 unit_vertex, vec2 glyph_position, vec2 glyph_size) {
-  vec4 translate = mvp[0] * glyph_position.x
-                 + mvp[1] * glyph_position.y
-                 + mvp[3];
-  mat4 translated_mvp = mat4(
-    mvp[0],
-    mvp[1],
-    mvp[2],
-    vec4(
-      translate.xyz,
-      mvp[3].w
-    )
-  );
-  return translated_mvp *
-         vec4(unit_vertex.x * glyph_size.x,
-              unit_vertex.y * glyph_size.y, 0.0, 1.0);
-}
-
 #endif

impeller/entity/BUILD.gn

@@ -36,8 +36,6 @@ impeller_shaders("entity_shaders") {
     "shaders/gaussian_blur.vert",
     "shaders/glyph_atlas.frag",
     "shaders/glyph_atlas.vert",
-    "shaders/glyph_atlas_sdf.frag",
-    "shaders/glyph_atlas_sdf.vert",
     "shaders/gradient_fill.vert",
     "shaders/linear_to_srgb_filter.frag",
     "shaders/linear_to_srgb_filter.vert",

impeller/entity/contents/content_context.cc

@@ -207,8 +207,6 @@ ContentContext::ContentContext(std::shared_ptr<Context> context)
       CreateDefaultPipeline<SolidStrokePipeline>(*context_);
   glyph_atlas_pipelines_[{}] =
       CreateDefaultPipeline<GlyphAtlasPipeline>(*context_);
-  glyph_atlas_sdf_pipelines_[{}] =
-      CreateDefaultPipeline<GlyphAtlasSdfPipeline>(*context_);
   vertices_pipelines_[{}] = CreateDefaultPipeline<VerticesPipeline>(*context_);
   atlas_pipelines_[{}] = CreateDefaultPipeline<AtlasPipeline>(*context_);
 

impeller/entity/contents/content_context.h

@@ -40,8 +40,6 @@
 #include "impeller/entity/gaussian_blur.vert.h"
 #include "impeller/entity/glyph_atlas.frag.h"
 #include "impeller/entity/glyph_atlas.vert.h"
-#include "impeller/entity/glyph_atlas_sdf.frag.h"
-#include "impeller/entity/glyph_atlas_sdf.vert.h"
 #include "impeller/entity/gradient_fill.vert.h"
 #include "impeller/entity/linear_gradient_fill.frag.h"
 #include "impeller/entity/linear_to_srgb_filter.frag.h"
@@ -146,8 +144,6 @@ using SolidStrokePipeline =
     RenderPipelineT<SolidStrokeVertexShader, SolidStrokeFragmentShader>;
 using GlyphAtlasPipeline =
     RenderPipelineT<GlyphAtlasVertexShader, GlyphAtlasFragmentShader>;
-using GlyphAtlasSdfPipeline =
-    RenderPipelineT<GlyphAtlasSdfVertexShader, GlyphAtlasSdfFragmentShader>;
 using VerticesPipeline =
     RenderPipelineT<VerticesVertexShader, VerticesFragmentShader>;
 using AtlasPipeline =
@@ -276,11 +272,6 @@ class ContentContext {
     return GetPipeline(glyph_atlas_pipelines_, opts);
   }
 
-  std::shared_ptr<Pipeline<PipelineDescriptor>> GetGlyphAtlasSdfPipeline(
-      ContentContextOptions opts) const {
-    return GetPipeline(glyph_atlas_sdf_pipelines_, opts);
-  }
-
   std::shared_ptr<Pipeline<PipelineDescriptor>> GetVerticesPipeline(
       ContentContextOptions opts) const {
     return GetPipeline(vertices_pipelines_, opts);
@@ -408,7 +399,6 @@ class ContentContext {
   mutable Variants<SolidStrokePipeline> solid_stroke_pipelines_;
   mutable Variants<ClipPipeline> clip_pipelines_;
   mutable Variants<GlyphAtlasPipeline> glyph_atlas_pipelines_;
-  mutable Variants<GlyphAtlasSdfPipeline> glyph_atlas_sdf_pipelines_;
   mutable Variants<VerticesPipeline> vertices_pipelines_;
   mutable Variants<AtlasPipeline> atlas_pipelines_;
   // Advanced blends.

impeller/entity/contents/text_contents.cc

@@ -4,8 +4,8 @@
 
 #include "impeller/entity/contents/text_contents.h"
 
+#include <iostream>
 #include <optional>
-#include <type_traits>
 
 #include "impeller/entity/contents/content_context.h"
 #include "impeller/entity/entity.h"
@@ -28,16 +28,22 @@ void TextContents::SetTextFrame(TextFrame frame) {
   frame_ = std::move(frame);
 }
 
+void TextContents::SetGlyphAtlas(std::shared_ptr<GlyphAtlas> atlas) {
+  atlas_ = std::move(atlas);
+}
+
 void TextContents::SetGlyphAtlas(std::shared_ptr<LazyGlyphAtlas> atlas) {
-  lazy_atlas_ = std::move(atlas);
+  atlas_ = std::move(atlas);
 }
 
 std::shared_ptr<GlyphAtlas> TextContents::ResolveAtlas(
-    GlyphAtlas::Type type,
     std::shared_ptr<Context> context) const {
-  FML_DCHECK(lazy_atlas_);
-  if (lazy_atlas_) {
-    return lazy_atlas_->CreateOrGetGlyphAtlas(type, context);
+  if (auto lazy_atlas = std::get_if<std::shared_ptr<LazyGlyphAtlas>>(&atlas_)) {
+    return lazy_atlas->get()->CreateOrGetGlyphAtlas(context);
+  }
+
+  if (auto atlas = std::get_if<std::shared_ptr<GlyphAtlas>>(&atlas_)) {
+    return *atlas;
   }
 
   return nullptr;
@@ -55,19 +61,33 @@ std::optional<Rect> TextContents::GetCoverage(const Entity& entity) const {
   return bounds->TransformBounds(entity.GetTransformation());
 }
 
-template <class TPipeline>
-static bool CommonRender(const ContentContext& renderer,
-                         const Entity& entity,
-                         RenderPass& pass,
-                         const Color& color,
-                         const TextFrame& frame,
-                         std::shared_ptr<GlyphAtlas> atlas,
-                         Command& cmd) {
-  using VS = typename TPipeline::VertexShader;
-  using FS = typename TPipeline::FragmentShader;
+bool TextContents::Render(const ContentContext& renderer,
+                          const Entity& entity,
+                          RenderPass& pass) const {
+  if (color_.IsTransparent()) {
+    return true;
+  }
+
+  auto atlas = ResolveAtlas(renderer.GetContext());
+
+  if (!atlas || !atlas->IsValid()) {
+    VALIDATION_LOG << "Cannot render glyphs without prepared atlas.";
+    return false;
+  }
+
+  using VS = GlyphAtlasPipeline::VertexShader;
+  using FS = GlyphAtlasPipeline::FragmentShader;
+
+  // Information shared by all glyph draw calls.
+  Command cmd;
+  cmd.label = "TextFrame";
+  cmd.primitive_type = PrimitiveType::kTriangle;
+  cmd.pipeline =
+      renderer.GetGlyphAtlasPipeline(OptionsFromPassAndEntity(pass, entity));
+  cmd.stencil_reference = entity.GetStencilDepth();
 
   // Common vertex uniforms for all glyphs.
-  typename VS::FrameInfo frame_info;
+  VS::FrameInfo frame_info;
   frame_info.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                    entity.GetTransformation();
   VS::BindFrameInfo(cmd, pass.GetTransientsBuffer().EmplaceUniform(frame_info));
@@ -76,8 +96,8 @@ static bool CommonRender(const ContentContext& renderer,
   sampler_desc.min_filter = MinMagFilter::kLinear;
   sampler_desc.mag_filter = MinMagFilter::kLinear;
 
-  typename FS::FragInfo frag_info;
-  frag_info.text_color = ToVector(color.Premultiply());
+  FS::FragInfo frag_info;
+  frag_info.text_color = ToVector(color_.Premultiply());
   frag_info.atlas_size =
       Point{static_cast<Scalar>(atlas->GetTexture()->GetSize().width),
             static_cast<Scalar>(atlas->GetTexture()->GetSize().height)};
@@ -102,15 +122,16 @@ static bool CommonRender(const ContentContext& renderer,
       {0, 0}, {1, 0}, {0, 1}, {1, 0}, {0, 1}, {1, 1},
   };
 
-  VertexBufferBuilder<typename VS::PerVertexData> vertex_builder;
-  for (const auto& run : frame.GetRuns()) {
+  VertexBufferBuilder<VS::PerVertexData> vertex_builder;
+  for (const auto& run : frame_.GetRuns()) {
     auto font = run.GetFont();
     auto glyph_size = ISize::Ceil(font.GetMetrics().GetBoundingBox().size);
     for (const auto& glyph_position : run.GetGlyphPositions()) {
       FontGlyphPair font_glyph_pair{font, glyph_position.glyph};
-
+      auto color_glyph =
+          atlas->IsColorFontGlyphPair(font_glyph_pair) ? 1.0 : 0.0;
       for (const auto& point : unit_vertex_points) {
-        typename VS::PerVertexData vtx;
+        VS::PerVertexData vtx;
         vtx.unit_vertex = point;
 
         auto atlas_glyph_pos = atlas->FindFontGlyphPosition(font_glyph_pair);
@@ -128,10 +149,7 @@ static bool CommonRender(const ContentContext& renderer,
                                             1 / atlas_glyph_pos->size.height};
         vtx.atlas_glyph_size =
             Point{atlas_glyph_pos->size.width, atlas_glyph_pos->size.height};
-        if constexpr (std::is_same_v<TPipeline, GlyphAtlasPipeline>) {
-          vtx.color_glyph =
-              glyph_position.glyph.type == Glyph::Type::kBitmap ? 1.0 : 0.0;
-        }
+        vtx.color_glyph = color_glyph;
         vertex_builder.AppendVertex(std::move(vtx));
       }
     }
@@ -147,55 +165,4 @@ static bool CommonRender(const ContentContext& renderer,
   return true;
 }
 
-bool TextContents::RenderSdf(const ContentContext& renderer,
-                             const Entity& entity,
-                             RenderPass& pass) const {
-  auto atlas = ResolveAtlas(GlyphAtlas::Type::kSignedDistanceField,
-                            renderer.GetContext());
-
-  if (!atlas || !atlas->IsValid()) {
-    VALIDATION_LOG << "Cannot render glyphs without prepared atlas.";
-    return false;
-  }
-
-  // Information shared by all glyph draw calls.
-  Command cmd;
-  cmd.label = "TextFrameSDF";
-  cmd.primitive_type = PrimitiveType::kTriangle;
-  cmd.pipeline =
-      renderer.GetGlyphAtlasSdfPipeline(OptionsFromPassAndEntity(pass, entity));
-  cmd.stencil_reference = entity.GetStencilDepth();
-
-  return CommonRender<GlyphAtlasSdfPipeline>(renderer, entity, pass, color_,
-                                             frame_, atlas, cmd);
-}
-
-bool TextContents::Render(const ContentContext& renderer,
-                          const Entity& entity,
-                          RenderPass& pass) const {
-  if (color_.IsTransparent()) {
-    return true;
-  }
-
-  auto atlas = ResolveAtlas(frame_.HasColor() ? GlyphAtlas::Type::kColorBitmap
-                                              : GlyphAtlas::Type::kAlphaBitmap,
-                            renderer.GetContext());
-
-  if (!atlas || !atlas->IsValid()) {
-    VALIDATION_LOG << "Cannot render glyphs without prepared atlas.";
-    return false;
-  }
-
-  // Information shared by all glyph draw calls.
-  Command cmd;
-  cmd.label = "TextFrame";
-  cmd.primitive_type = PrimitiveType::kTriangle;
-  cmd.pipeline =
-      renderer.GetGlyphAtlasPipeline(OptionsFromPassAndEntity(pass, entity));
-  cmd.stencil_reference = entity.GetStencilDepth();
-
-  return CommonRender<GlyphAtlasPipeline>(renderer, entity, pass, color_,
-                                          frame_, atlas, cmd);
-}
-
 }  // namespace impeller

impeller/entity/contents/text_contents.h

@@ -12,11 +12,11 @@
 #include "flutter/fml/macros.h"
 #include "impeller/entity/contents/contents.h"
 #include "impeller/geometry/color.h"
-#include "impeller/typographer/glyph_atlas.h"
 #include "impeller/typographer/text_frame.h"
 
 namespace impeller {
 
+class GlyphAtlas;
 class LazyGlyphAtlas;
 class Context;
 
@@ -28,6 +28,8 @@ class TextContents final : public Contents {
 
   void SetTextFrame(TextFrame frame);
 
+  void SetGlyphAtlas(std::shared_ptr<GlyphAtlas> atlas);
+
   void SetGlyphAtlas(std::shared_ptr<LazyGlyphAtlas> atlas);
 
   void SetColor(Color color);
@@ -40,18 +42,14 @@ class TextContents final : public Contents {
               const Entity& entity,
               RenderPass& pass) const override;
 
-  // TODO(dnfield): remove this https://github.com/flutter/flutter/issues/111640
-  bool RenderSdf(const ContentContext& renderer,
-                 const Entity& entity,
-                 RenderPass& pass) const;
-
  private:
   TextFrame frame_;
   Color color_;
-  mutable std::shared_ptr<LazyGlyphAtlas> lazy_atlas_;
+  mutable std::variant<std::shared_ptr<GlyphAtlas>,
+                       std::shared_ptr<LazyGlyphAtlas>>
+      atlas_;
 
   std::shared_ptr<GlyphAtlas> ResolveAtlas(
-      GlyphAtlas::Type type,
       std::shared_ptr<Context> context) const;
 
   FML_DISALLOW_COPY_AND_ASSIGN(TextContents);

impeller/entity/entity_unittests.cc

@@ -20,7 +20,6 @@
 #include "impeller/entity/contents/rrect_shadow_contents.h"
 #include "impeller/entity/contents/solid_color_contents.h"
 #include "impeller/entity/contents/solid_stroke_contents.h"
-#include "impeller/entity/contents/text_contents.h"
 #include "impeller/entity/contents/texture_contents.h"
 #include "impeller/entity/contents/vertices_contents.h"
 #include "impeller/entity/entity.h"
@@ -36,11 +35,8 @@
 #include "impeller/renderer/render_pass.h"
 #include "impeller/renderer/vertex_buffer_builder.h"
 #include "impeller/tessellator/tessellator.h"
-#include "impeller/typographer/backends/skia/text_frame_skia.h"
-#include "impeller/typographer/backends/skia/text_render_context_skia.h"
 #include "include/core/SkBlendMode.h"
 #include "third_party/imgui/imgui.h"
-#include "third_party/skia/include/core/SkTextBlob.h"
 
 namespace impeller {
 namespace testing {
@@ -1980,31 +1976,5 @@ TEST_P(EntityTest, TTTBlendColor) {
   }
 }
 
-TEST_P(EntityTest, SdfText) {
-  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
-    SkFont font;
-    font.setSize(30);
-    auto blob = SkTextBlob::MakeFromString(
-        "the quick brown fox jumped over the lazy dog (but with sdf).", font);
-    auto frame = TextFrameFromTextBlob(blob);
-    auto lazy_glyph_atlas = std::make_shared<LazyGlyphAtlas>();
-    lazy_glyph_atlas->AddTextFrame(frame);
-
-    auto text_contents = std::make_shared<TextContents>();
-    text_contents->SetTextFrame(std::move(frame));
-    text_contents->SetGlyphAtlas(std::move(lazy_glyph_atlas));
-    text_contents->SetColor(Color(1.0, 0.0, 0.0, 1.0));
-    Entity entity;
-    entity.SetTransformation(
-        Matrix::MakeTranslation(Vector3{200.0, 200.0, 0.0}) *
-        Matrix::MakeScale(GetContentScale()));
-    entity.SetContents(text_contents);
-
-    // Force SDF rendering.
-    return text_contents->RenderSdf(context, entity, pass);
-  };
-  ASSERT_TRUE(OpenPlaygroundHere(callback));
-}
-
 }  // namespace testing
 }  // namespace impeller