impeller::interop::testing Namespace Reference

Classes
class	ContextSub
class	FlagObject
class	PlaygroundTest
class	TestObject

Typedefs
using	InteropPlaygroundTest = PlaygroundTest

Functions
	INSTANTIATE_PLAYGROUND_SUITE (InteropPlaygroundTest)
	TEST_P (InteropPlaygroundTest, CanCreateContext)
	TEST_P (InteropPlaygroundTest, CanCreateDisplayListBuilder)
	TEST_P (InteropPlaygroundTest, CanCreateSurface)
	TEST_P (InteropPlaygroundTest, CanDrawRect)
	TEST_P (InteropPlaygroundTest, CanDrawImage)
	TEST_P (InteropPlaygroundTest, CanCreateOpenGLImage)
	TEST_P (InteropPlaygroundTest, ClearsOpenGLStancilStateAfterTransition)
	TEST_P (InteropPlaygroundTest, CanCreateParagraphs)
	TEST_P (InteropPlaygroundTest, CanCreateDecorations)
	TEST_P (InteropPlaygroundTest, CanCreateShapes)
	TEST_P (InteropPlaygroundTest, CanCreateParagraphsWithCustomFont)
static void	DrawTextFrame (const hpp::TypographyContext &tc, hpp::DisplayListBuilder &builder, hpp::ParagraphStyle &p_style, const hpp::Paint &bg, ImpellerColor color, ImpellerTextAlignment align, float x_offset)
	TEST_P (InteropPlaygroundTest, CanRenderTextAlignments)
	TEST_P (InteropPlaygroundTest, CanRenderShadows)
	TEST_P (InteropPlaygroundTest, CanMeasureText)
	TEST_P (InteropPlaygroundTest, CanGetPathBounds)
	TEST_P (InteropPlaygroundTest, CanControlEllipses)
	TEST_P (InteropPlaygroundTest, CanCreateFragmentProgramColorFilters)
	TEST_P (InteropPlaygroundTest, MappingsReleaseTheirDataOnDestruction)
	IMPELLER_DEFINE_HANDLE (FlagHandle)
	IMPELLER_DEFINE_HANDLE (TestHandle)
	TEST (InteropObjectTest, CanCreateScoped)
	TEST (InteropObjectTest, CanCreate)
	TEST (InteropObjectTest, CanCopyAssignMove)
static void	SetupImpellerHPPProcTableOnce ()
static ScopedObject< Surface >	CreateSharedSurface (PlaygroundBackend backend, Context &context, std::shared_ptr< impeller::Surface > shared_surface)
static ScopedObject< Context >	CreateSharedContext (PlaygroundBackend backend, std::shared_ptr< impeller::Context > shared_context)

Typedef Documentation

InteropPlaygroundTest

using impeller::interop::testing::InteropPlaygroundTest = typedef PlaygroundTest

Definition at line 27 of file impeller_unittests.cc.

Function Documentation

CreateSharedContext()

static ScopedObject< Context > impeller::interop::testing::CreateSharedContext ( PlaygroundBackend  backend, std::shared_ptr< impeller::Context >  shared_context  )

static

Definition at line 150 of file playground_test.cc.

                                                   {
  switch (backend) {
#if IMPELLER_ENABLE_METAL
    case PlaygroundBackend::kMetal:
    case PlaygroundBackend::kMetalSDF:
      return ContextMTL::Create(shared_context);
#endif
#if IMPELLER_ENABLE_OPENGLES
    case PlaygroundBackend::kOpenGLES:
    case PlaygroundBackend::kOpenGLESSDF:
      return ContextGLES::Create(std::move(shared_context));
#endif
#if IMPELLER_ENABLE_VULKAN
    case PlaygroundBackend::kVulkan:
      return ContextVK::Create(std::move(shared_context));
#endif
    default:
      return nullptr;
  }
  FML_UNREACHABLE();
}

References impeller::interop::ContextMTL::Create(), impeller::interop::ContextVK::Create(), impeller::interop::ContextGLES::Create(), FML_UNREACHABLE, impeller::kMetal, impeller::kMetalSDF, impeller::kOpenGLES, impeller::kOpenGLESSDF, and impeller::kVulkan.

Referenced by impeller::interop::testing::PlaygroundTest::GetInteropContext().

CreateSharedSurface()

static ScopedObject< Surface > impeller::interop::testing::CreateSharedSurface ( PlaygroundBackend  backend, Context &  context, std::shared_ptr< impeller::Surface >  shared_surface  )

static

Definition at line 103 of file playground_test.cc.

                                                   {
  switch (backend) {
#if IMPELLER_ENABLE_METAL
    case PlaygroundBackend::kMetal:
    case PlaygroundBackend::kMetalSDF:
      return Adopt<Surface>(new SurfaceMTL(context, std::move(shared_surface)));
#endif
 
#if IMPELLER_ENABLE_OPENGLES
    case PlaygroundBackend::kOpenGLES:
    case PlaygroundBackend::kOpenGLESSDF:
      return Adopt<Surface>(
          new SurfaceGLES(context, std::move(shared_surface)));
#endif
 
#if IMPELLER_ENABLE_VULKAN
    case PlaygroundBackend::kVulkan:
      return Adopt<Surface>(new SurfaceVK(context, std::move(shared_surface)));
#endif
    default:
      return nullptr;
  }
  FML_UNREACHABLE();
}

References context, FML_UNREACHABLE, impeller::kMetal, impeller::kMetalSDF, impeller::kOpenGLES, impeller::kOpenGLESSDF, and impeller::kVulkan.

Referenced by impeller::interop::testing::PlaygroundTest::OpenPlaygroundHere().

DrawTextFrame()

static void impeller::interop::testing::DrawTextFrame ( const hpp::TypographyContext &  tc, hpp::DisplayListBuilder &  builder, hpp::ParagraphStyle &  p_style, const hpp::Paint &  bg, ImpellerColor  color, ImpellerTextAlignment  align, float  x_offset  )

static

Definition at line 430 of file impeller_unittests.cc.

                                          {
  const char text[] =
      "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
 
  hpp::Paint fg;
 
  // Draw a box.
  fg.SetColor(color);
  fg.SetDrawStyle(kImpellerDrawStyleStroke);
  ImpellerRect box_rect = {10 + x_offset, 10, 200, 200};
  builder.DrawRect(box_rect, fg);
 
  // Draw text.
  fg.SetDrawStyle(kImpellerDrawStyleFill);
  p_style.SetForeground(fg);
  p_style.SetBackground(bg);
  p_style.SetTextAlignment(align);
 
  hpp::ParagraphBuilder p_builder(tc);
  p_builder.PushStyle(p_style);
  p_builder.AddText(reinterpret_cast<const uint8_t*>(text), sizeof(text));
 
  auto left_p = p_builder.Build(box_rect.width - 20.0);
  ImpellerPoint pt = {20.0f + x_offset, 20.0f};
  float w = left_p.GetMaxWidth();
  float h = left_p.GetHeight();
  builder.DrawParagraph(left_p, pt);
  fg.SetDrawStyle(kImpellerDrawStyleStroke);
 
  // Draw an inner box around the paragraph layout.
  ImpellerRect inner_box_rect = {pt.x, pt.y, w, h};
  builder.DrawRect(inner_box_rect, fg);
}

References kImpellerDrawStyleFill, kImpellerDrawStyleStroke, text, ImpellerRect::width, ImpellerPoint::x, and ImpellerPoint::y.

Referenced by TEST_P().

IMPELLER_DEFINE_HANDLE() [1/2]

impeller::interop::testing::IMPELLER_DEFINE_HANDLE

(

FlagHandle

)

IMPELLER_DEFINE_HANDLE() [2/2]

impeller::interop::testing::IMPELLER_DEFINE_HANDLE

(

TestHandle

)

INSTANTIATE_PLAYGROUND_SUITE()

impeller::interop::testing::INSTANTIATE_PLAYGROUND_SUITE

(

InteropPlaygroundTest

)

SetupImpellerHPPProcTableOnce()

static void impeller::interop::testing::SetupImpellerHPPProcTableOnce ( )

static

Definition at line 30 of file playground_test.cc.

                                            {
  static std::once_flag sOnceFlag;
  std::call_once(sOnceFlag, []() {
    std::map<std::string, void*> proc_map;
#define IMPELLER_HPP_PROC(name) \
  proc_map[#name] = reinterpret_cast<void*>(&name);
    IMPELLER_HPP_EACH_PROC(IMPELLER_HPP_PROC)
#undef IMPELLER_HPP_PROC
    hpp::gGlobalProcTable.Initialize(
        [&](auto name) { return proc_map.at(name); });
  });
}

References IMPELLER_HPP_PROC, and name.

Referenced by impeller::interop::testing::PlaygroundTest::PlaygroundTest().

TEST() [1/3]

impeller::interop::testing::TEST	(	InteropObjectTest	,
		CanCopyAssignMove
	)

Definition at line 77 of file object_unittests.cc.

                                           {
  auto o = Create<TestObject>(1, 2.3, 'd');
  ASSERT_EQ(o->GetRefCountForTests(), 1u);
  {
    auto o1 = o;  // NOLINT(performance-unnecessary-copy-initialization)
    ASSERT_EQ(o->GetRefCountForTests(), 2u);
    auto o2 = o;  // NOLINT(performance-unnecessary-copy-initialization)
    ASSERT_EQ(o->GetRefCountForTests(), 3u);
    auto o3 = o1;  // NOLINT(performance-unnecessary-copy-initialization)
    ASSERT_EQ(o->GetRefCountForTests(), 4u);
  }
  ASSERT_EQ(o->GetRefCountForTests(), 1u);
 
  {
    auto o1(o);  // NOLINT(performance-unnecessary-copy-initialization)
    ASSERT_EQ(o->GetRefCountForTests(), 2u);
    ASSERT_EQ(o1->GetRefCountForTests(), 2u);
  }
 
  auto move_o = std::move(o);
  ASSERT_EQ(move_o->GetRefCountForTests(), 1u);
}

TEST() [2/3]

impeller::interop::testing::TEST	(	InteropObjectTest	,
		CanCreate
	)

Definition at line 70 of file object_unittests.cc.

                                   {
  auto object = Create<TestObject>(1, 1.3, 'c');
  ASSERT_EQ(object->GetArg1(), 1);
  ASSERT_EQ(object->GetArg2(), 1.3);
  ASSERT_EQ(object->GetArg3(), 'c');
}

TEST() [3/3]

impeller::interop::testing::TEST	(	InteropObjectTest	,
		CanCreateScoped
	)

Definition at line 54 of file object_unittests.cc.

                                         {
  bool destructed = false;
  {
    auto object = Adopt(new FlagObject(destructed));  //
  }
  ASSERT_TRUE(destructed);
 
  destructed = false;
  {
    auto object = Ref(new FlagObject(destructed));
    // New objects start with retain count of 1.
    object->Release();
  }
  ASSERT_TRUE(destructed);
}

References impeller::interop::Adopt(), and impeller::interop::Ref().

TEST_P() [1/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanControlEllipses
	)

Definition at line 636 of file impeller_unittests.cc.

                                                  {
  hpp::TypographyContext context;
  auto style = hpp::ParagraphStyle{};
  style.SetFontSize(50);
  style.SetForeground(hpp::Paint{}.SetColor({.red = 1.0, .alpha = 1.0}));
  const auto text = std::string{"The quick brown fox jumped over the lazy dog"};
  style.SetEllipsis("🐶");
  auto para1 =
      hpp::ParagraphBuilder{context}.PushStyle(style).AddText(text).Build(250);
  style.SetForeground(hpp::Paint{}.SetColor({.green = 1.0, .alpha = 1.0}));
  style.SetEllipsis(nullptr);
  auto para2 =
      hpp::ParagraphBuilder{context}.PushStyle(style).AddText(text).Build(250);
  auto dl = hpp::DisplayListBuilder{}
                .DrawParagraph(para1, {100, 100})
                .DrawParagraph(para2, {100, 200})
                .Build();
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        hpp::Surface window(surface.GetC());
        window.Draw(dl);
        return true;
      }));
}

References context, surface, text, and window.

TEST_P() [2/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanCreateContext
	)

Definition at line 33 of file impeller_unittests.cc.

                                                {
  auto context = CreateContext();
  ASSERT_TRUE(context);
}

References context.

TEST_P() [3/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanCreateDecorations
	)

Definition at line 297 of file impeller_unittests.cc.

                                                    {
  hpp::TypographyContext context;
  auto para =
      hpp::ParagraphBuilder(context)
          .PushStyle(
              hpp::ParagraphStyle{}
                  .SetForeground(hpp::Paint{}.SetColor({1.0, 0.0, 0.0, 1.0}))
                  .SetFontSize(150.0f)
                  .SetTextDecoration(ImpellerTextDecoration{
                      .types = kImpellerTextDecorationTypeLineThrough |
                               kImpellerTextDecorationTypeUnderline,
                      .color = ImpellerColor{0.0, 1.0, 0.0, 0.75},
                      .style = kImpellerTextDecorationStyleWavy,
                      .thickness_multiplier = 1.5,
                  }))
          .AddText(std::string{"Holy text decorations Batman!"})
          .Build(900);
  auto dl = hpp::DisplayListBuilder{}.DrawParagraph(para, {100, 100}).Build();
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        hpp::Surface window(surface.GetC());
        window.Draw(dl);
        return true;
      }));
}

References context, kImpellerTextDecorationStyleWavy, kImpellerTextDecorationTypeLineThrough, kImpellerTextDecorationTypeUnderline, surface, ImpellerTextDecoration::types, and window.

TEST_P() [4/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanCreateDisplayListBuilder
	)

Definition at line 38 of file impeller_unittests.cc.

                                                           {
  hpp::DisplayListBuilder builder;
  ASSERT_TRUE(builder);
  ASSERT_TRUE(ToImpellerType(builder.GetTransform()).IsIdentity());
  ASSERT_EQ(builder.GetSaveCount(), 1u);
  builder.Save();
  ASSERT_EQ(builder.GetSaveCount(), 2u);
  builder.Restore();
  ASSERT_EQ(builder.GetSaveCount(), 1u);
}

References impeller::Matrix::IsIdentity(), and impeller::interop::ToImpellerType().

TEST_P() [5/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanCreateFragmentProgramColorFilters
	)

Definition at line 661 of file impeller_unittests.cc.

                                                                    {
  auto iplr = OpenAssetAsHPPMapping("interop_runtime_stage_cs.frag.iplr");
  ASSERT_TRUE(!!iplr);
  auto program = hpp::FragmentProgram::WithData(std::move(iplr));
  ASSERT_TRUE(program);
  auto context = GetHPPContext();
  auto filter =
      hpp::ImageFilter::FragmentProgram(context, program, {}, nullptr);
  ASSERT_TRUE(filter);
  auto bay_bridge = OpenAssetAsHPPTexture("bay_bridge.jpg");
  ASSERT_TRUE(bay_bridge);
 
  float size_data[4] = {500, 500};
  auto uniform_data = hpp::Mapping{reinterpret_cast<const uint8_t*>(&size_data),
                                   sizeof(size_data), nullptr};
 
  auto dl = hpp::DisplayListBuilder{}
                .DrawRect({10, 10, 500, 500},
                          hpp::Paint{}
                              .SetColor({1.0, 1.0, 1.0, 1.0})
                              .SetColorSource(hpp::ColorSource::FragmentProgram(
                                  context,             //
                                  program,             //
                                  {bay_bridge.Get()},  // samplers
                                  &uniform_data        // uniform data
                                  )))
                .Build();
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        hpp::Surface window(surface.GetC());
        window.Draw(dl);
        return true;
      }));
}

References context, surface, and window.

TEST_P() [6/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanCreateOpenGLImage
	)

Definition at line 134 of file impeller_unittests.cc.

                                                    {
  auto context = GetInteropContext();
 
  auto impeller_context = context->GetContext();
 
  if (impeller_context->GetBackendType() !=
      impeller::Context::BackendType::kOpenGLES) {
    GTEST_SKIP() << "This test works with OpenGL handles is only suitable for "
                    "that backend.";
    return;
  }
 
  const auto& gl_context = ContextGLES::Cast(*impeller_context);
  const auto& gl = gl_context.GetReactor()->GetProcTable();
 
  constexpr ISize external_texture_size = {200, 300};
 
  Allocation texture_data;
  ASSERT_TRUE(
      texture_data.Truncate(Bytes{external_texture_size.Area() * 4u}, false));
 
  const auto kClearColor = Color::Fuchsia().ToR8G8B8A8();
 
  for (size_t i = 0; i < external_texture_size.Area() * 4u; i += 4u) {
    memcpy(texture_data.GetBuffer() + i, kClearColor.data(), 4);
  }
 
  GLuint external_texture = GL_NONE;
  gl.GenTextures(1u, &external_texture);
  ASSERT_NE(external_texture, 0u);
  gl.BindTexture(GL_TEXTURE_2D, external_texture);
  gl.TexImage2D(GL_TEXTURE_2D,                 //
                0,                             //
                GL_RGBA,                       //
                external_texture_size.width,   //
                external_texture_size.height,  //
                0,                             //
                GL_RGBA,                       //
                GL_UNSIGNED_BYTE,              //
                texture_data.GetBuffer()       //
  );
 
  ImpellerTextureDescriptor desc = {};
  desc.pixel_format = ImpellerPixelFormat::kImpellerPixelFormatRGBA8888;
  desc.size = {external_texture_size.width, external_texture_size.height};
  desc.mip_count = 1u;
  auto texture = Adopt<Texture>(ImpellerTextureCreateWithOpenGLTextureHandleNew(
      context.GetC(),   //
      &desc,            //
      external_texture  //
      ));
  ASSERT_TRUE(texture);
 
  ASSERT_EQ(ImpellerTextureGetOpenGLHandle(texture.GetC()), external_texture);
 
  auto builder =
      Adopt<DisplayListBuilder>(ImpellerDisplayListBuilderNew(nullptr));
  ImpellerPoint point = {100, 100};
  ImpellerDisplayListBuilderDrawTexture(builder.GetC(), texture.GetC(), &point,
                                        kImpellerTextureSamplingLinear,
                                        nullptr);
  auto dl = Adopt<DisplayList>(
      ImpellerDisplayListBuilderCreateDisplayListNew(builder.GetC()));
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        ImpellerSurfaceDrawDisplayList(surface.GetC(), dl.GetC());
        return true;
      }));
}

References impeller::TSize< T >::Area(), impeller::BackendCast< ContextGLES, Context >::Cast(), context, impeller::Color::Fuchsia(), impeller::Allocation::GetBuffer(), impeller::TSize< T >::height, i, impeller::interop::ImpellerDisplayListBuilderCreateDisplayListNew(), impeller::interop::ImpellerDisplayListBuilderDrawTexture(), impeller::interop::ImpellerDisplayListBuilderNew(), impeller::interop::ImpellerSurfaceDrawDisplayList(), impeller::interop::ImpellerTextureCreateWithOpenGLTextureHandleNew(), impeller::interop::ImpellerTextureGetOpenGLHandle(), kImpellerTextureSamplingLinear, impeller::Context::kOpenGLES, ImpellerTextureDescriptor::mip_count, ImpellerTextureDescriptor::pixel_format, ImpellerTextureDescriptor::size, surface, texture, impeller::Color::ToR8G8B8A8(), impeller::Allocation::Truncate(), and impeller::TSize< T >::width.

TEST_P() [7/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanCreateParagraphs
	)

Definition at line 242 of file impeller_unittests.cc.

                                                   {
  // Create a typography context.
  hpp::TypographyContext type_context;
  ASSERT_TRUE(type_context);
 
  // Create a builder.
  hpp::ParagraphBuilder builder(type_context);
  ASSERT_TRUE(builder);
 
  // Create a paragraph style with the font size and foreground and background
  // colors.
  hpp::ParagraphStyle style;
  ASSERT_TRUE(style);
  style.SetFontSize(150.0f);
  style.SetHeight(2.0f);
 
  {
    hpp::Paint paint;
    ASSERT_TRUE(paint);
    paint.SetColor({1.0, 0.0, 0.0, 1.0});
    style.SetForeground(paint);
  }
 
  {
    hpp::Paint paint;
    paint.SetColor({1.0, 1.0, 1.0, 1.0});
    style.SetBackground(paint);
  }
 
  // Push the style onto the style stack.
  builder.PushStyle(style);
  std::string text = "the ⚡️ quick ⚡️ brown 🦊 fox jumps over the lazy dog 🐶.";
 
  // Add the paragraph text data.
  builder.AddText(text);
 
  // Layout and build the paragraph.
  auto paragraph = builder.Build(1200.0f);
  ASSERT_TRUE(paragraph);
 
  // Create a display list with just the paragraph drawn into it.
  hpp::DisplayListBuilder dl_builder;
  dl_builder.DrawParagraph(paragraph, {20, 20});
 
  // Build the display list.
  auto dl = dl_builder.Build();
 
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        hpp::Surface window(surface.GetC());
        window.Draw(dl);
        return true;
      }));
}

References context, surface, text, and window.

TEST_P() [8/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanCreateParagraphsWithCustomFont
	)

Definition at line 356 of file impeller_unittests.cc.

                                                                 {
  // Create a typography context.
  auto type_context = Adopt<TypographyContext>(ImpellerTypographyContextNew());
  ASSERT_TRUE(type_context);
 
  // Open the custom font file.
  std::unique_ptr<fml::Mapping> font_data =
      flutter::testing::OpenFixtureAsMapping("wtf.otf");
  ASSERT_NE(font_data, nullptr);
  ASSERT_GT(font_data->GetSize(), 0u);
  ImpellerMapping font_data_mapping = {
      .data = font_data->GetMapping(),
      .length = font_data->GetSize(),
      .on_release = [](auto ctx) {
        delete reinterpret_cast<fml::Mapping*>(ctx);
      }};
  auto registered =
      ImpellerTypographyContextRegisterFont(type_context.GetC(),  //
                                            &font_data_mapping,   //
                                            font_data.release(),  //
                                            nullptr               //
      );
  ASSERT_TRUE(registered);
 
  // Create a builder.
  auto builder =
      Adopt<ParagraphBuilder>(ImpellerParagraphBuilderNew(type_context.GetC()));
  ASSERT_TRUE(builder);
 
  // Create a paragraph style with the font size and foreground and background
  // colors.
  auto style = Adopt<ParagraphStyle>(ImpellerParagraphStyleNew());
  ASSERT_TRUE(style);
  ImpellerParagraphStyleSetFontSize(style.GetC(), 150.0f);
  ImpellerParagraphStyleSetFontFamily(style.GetC(), "WhatTheFlutter");
 
  {
    auto paint = Adopt<Paint>(ImpellerPaintNew());
    ASSERT_TRUE(paint);
    ImpellerColor color = {0.0, 1.0, 1.0, 1.0};
    ImpellerPaintSetColor(paint.GetC(), &color);
    ImpellerParagraphStyleSetForeground(style.GetC(), paint.GetC());
  }
 
  // Push the style onto the style stack.
  ImpellerParagraphBuilderPushStyle(builder.GetC(), style.GetC());
  std::string text = "0F0F0F0";
 
  // Add the paragraph text data.
  ImpellerParagraphBuilderAddText(builder.GetC(),
                                  reinterpret_cast<const uint8_t*>(text.data()),
                                  text.size());
 
  // Layout and build the paragraph.
  auto paragraph = Adopt<Paragraph>(
      ImpellerParagraphBuilderBuildParagraphNew(builder.GetC(), 1200.0f));
  ASSERT_TRUE(paragraph);
 
  // Create a display list with just the paragraph drawn into it.
  auto dl_builder =
      Adopt<DisplayListBuilder>(ImpellerDisplayListBuilderNew(nullptr));
  ImpellerPoint point = {20, 20};
  ImpellerDisplayListBuilderDrawParagraph(dl_builder.GetC(), paragraph.GetC(),
                                          &point);
  auto dl = Adopt<DisplayList>(
      ImpellerDisplayListBuilderCreateDisplayListNew(dl_builder.GetC()));
 
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        ImpellerSurfaceDrawDisplayList(surface.GetC(), dl.GetC());
        return true;
      }));
}  // namespace impeller::interop::testing

References context, ImpellerMapping::data, impeller::interop::ImpellerDisplayListBuilderCreateDisplayListNew(), impeller::interop::ImpellerDisplayListBuilderDrawParagraph(), impeller::interop::ImpellerDisplayListBuilderNew(), impeller::interop::ImpellerPaintNew(), impeller::interop::ImpellerPaintSetColor(), impeller::interop::ImpellerParagraphBuilderAddText(), impeller::interop::ImpellerParagraphBuilderBuildParagraphNew(), impeller::interop::ImpellerParagraphBuilderNew(), impeller::interop::ImpellerParagraphBuilderPushStyle(), impeller::interop::ImpellerParagraphStyleNew(), impeller::interop::ImpellerParagraphStyleSetFontFamily(), impeller::interop::ImpellerParagraphStyleSetFontSize(), impeller::interop::ImpellerParagraphStyleSetForeground(), impeller::interop::ImpellerSurfaceDrawDisplayList(), impeller::interop::ImpellerTypographyContextNew(), impeller::interop::ImpellerTypographyContextRegisterFont(), flutter::testing::OpenFixtureAsMapping(), surface, and text.

TEST_P() [9/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanCreateShapes
	)

Definition at line 323 of file impeller_unittests.cc.

                                               {
  hpp::DisplayListBuilder builder;
 
  hpp::Paint red_paint;
  red_paint.SetColor({1.0, 0.0, 0.0, 1.0});
  red_paint.SetStrokeWidth(10.0);
 
  builder.Translate(10, 10);
  builder.DrawRect({0, 0, 100, 100}, red_paint);
  builder.Translate(100, 100);
  builder.DrawOval({0, 0, 100, 100}, red_paint);
  builder.Translate(100, 100);
  builder.DrawLine({0, 0}, {100, 100}, red_paint);
 
  builder.Translate(100, 100);
  ImpellerRoundingRadii radii = {};
  radii.top_left = {10, 10};
  radii.bottom_right = {10, 10};
  builder.DrawRoundedRect({0, 0, 100, 100}, radii, red_paint);
 
  builder.Translate(100, 100);
  builder.DrawPath(hpp::PathBuilder{}.AddOval({0, 0, 100, 100}).Build(),
                   red_paint);
 
  auto dl = builder.Build();
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        hpp::Surface window(surface.GetC());
        window.Draw(dl);
        return true;
      }));
}

References ImpellerRoundingRadii::bottom_right, context, surface, ImpellerRoundingRadii::top_left, and window.

TEST_P() [10/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanCreateSurface
	)

Definition at line 49 of file impeller_unittests.cc.

                                                {
  if (GetBackend() != PlaygroundBackend::kOpenGLES &&
      GetBackend() != PlaygroundBackend::kOpenGLESSDF) {
    GTEST_SKIP()
        << "This test checks wrapping FBOs which is an OpenGL ES only call.";
    return;
  }
  auto context = CreateContext();
  ASSERT_TRUE(context);
  const auto window_size = GetWindowSize();
  ImpellerISize size = {window_size.width, window_size.height};
  auto surface = Adopt<Surface>(ImpellerSurfaceCreateWrappedFBONew(
      context.GetC(),                                     //
      0u,                                                 //
      ImpellerPixelFormat::kImpellerPixelFormatRGBA8888,  //
      &size)                                              //
  );
  ASSERT_TRUE(surface);
}

References context, impeller::interop::ImpellerSurfaceCreateWrappedFBONew(), impeller::kOpenGLES, impeller::kOpenGLESSDF, and surface.

TEST_P() [11/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanDrawImage
	)

Definition at line 100 of file impeller_unittests.cc.

                                            {
  auto compressed = LoadFixtureImageCompressed(
      flutter::testing::OpenFixtureAsMapping("boston.jpg"));
  ASSERT_NE(compressed, nullptr);
  auto decompressed = std::make_shared<impeller::DecompressedImage>(
      compressed->Decode().ConvertToRGBA());
  ASSERT_TRUE(decompressed->IsValid());
  auto mapping = std::make_unique<hpp::Mapping>(
      decompressed->GetAllocation()->GetMapping(),
      decompressed->GetAllocation()->GetSize(), [decompressed]() {
        // Mapping will be dropped on the floor.
      });
 
  auto context = GetHPPContext();
  ImpellerTextureDescriptor desc = {};
  desc.pixel_format = ImpellerPixelFormat::kImpellerPixelFormatRGBA8888;
  desc.size = {decompressed->GetSize().width, decompressed->GetSize().height};
  desc.mip_count = 1u;
  auto texture = hpp::Texture::WithContents(context, desc, std::move(mapping));
  ASSERT_TRUE(texture);
 
  auto dl = hpp::DisplayListBuilder{}
                .DrawTexture(texture, {100, 100},
                             kImpellerTextureSamplingLinear, hpp::Paint{})
                .Build();
 
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        hpp::Surface window(surface.GetC());
        window.Draw(dl);
        return true;
      }));
}

References context, kImpellerTextureSamplingLinear, ImpellerTextureDescriptor::mip_count, flutter::testing::OpenFixtureAsMapping(), ImpellerTextureDescriptor::pixel_format, ImpellerTextureDescriptor::size, surface, texture, ImpellerISize::width, and window.

TEST_P() [12/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanDrawRect
	)

Definition at line 69 of file impeller_unittests.cc.

                                           {
  auto builder =
      Adopt<DisplayListBuilder>(ImpellerDisplayListBuilderNew(nullptr));
  auto paint = Adopt<Paint>(ImpellerPaintNew());
  ImpellerColor color = {0.0, 0.0, 1.0, 1.0};
  ImpellerPaintSetColor(paint.GetC(), &color);
  ImpellerRect rect = {10, 20, 100, 200};
  ImpellerDisplayListBuilderDrawRect(builder.GetC(), &rect, paint.GetC());
  color = {1.0, 0.0, 0.0, 1.0};
  ImpellerPaintSetColor(paint.GetC(), &color);
  ImpellerDisplayListBuilderTranslate(builder.GetC(), 110, 210);
  ImpellerMatrix scale_transform = {
      // clang-format off
      2.0, 0.0, 0.0, 0.0, //
      0.0, 2.0, 0.0, 0.0, //
      0.0, 0.0, 1.0, 0.0, //
      0.0, 0.0, 0.0, 1.0, //
      // clang-format on
  };
  ImpellerDisplayListBuilderTransform(builder.GetC(), &scale_transform);
  ImpellerDisplayListBuilderDrawRect(builder.GetC(), &rect, paint.GetC());
  auto dl = Adopt<DisplayList>(
      ImpellerDisplayListBuilderCreateDisplayListNew(builder.GetC()));
  ASSERT_TRUE(dl);
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        ImpellerSurfaceDrawDisplayList(surface.GetC(), dl.GetC());
        return true;
      }));
}

References context, impeller::interop::ImpellerDisplayListBuilderCreateDisplayListNew(), impeller::interop::ImpellerDisplayListBuilderDrawRect(), impeller::interop::ImpellerDisplayListBuilderNew(), impeller::interop::ImpellerDisplayListBuilderTransform(), impeller::interop::ImpellerDisplayListBuilderTranslate(), impeller::interop::ImpellerPaintNew(), impeller::interop::ImpellerPaintSetColor(), impeller::interop::ImpellerSurfaceDrawDisplayList(), and surface.

TEST_P() [13/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanGetPathBounds
	)

Definition at line 626 of file impeller_unittests.cc.

                                                {
  const auto path =
      hpp::PathBuilder{}.MoveTo({100, 100}).LineTo({200, 200}).Build();
  const auto bounds = path.GetBounds();
  ASSERT_EQ(bounds.x, 100);
  ASSERT_EQ(bounds.y, 100);
  ASSERT_EQ(bounds.width, 100);
  ASSERT_EQ(bounds.height, 100);
}

References impeller::LineTo().

TEST_P() [14/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanMeasureText
	)

Definition at line 538 of file impeller_unittests.cc.

                                              {
  hpp::TypographyContext type_context;
  hpp::ParagraphBuilder paragraph_builder(type_context);
  hpp::ParagraphStyle paragraph_style;
  paragraph_style.SetFontSize(50);
  paragraph_builder.PushStyle(paragraph_style);
  const std::string text =
      "🏁 Can 👨‍👨‍👦‍👦 Measure 🔍 Text\nAnd this is line "
      "two.\nWhoa! Three lines. How high does this go?\r\nI stopped counting.";
  const auto u16text = fml::Utf8ToUtf16(text);
  ASSERT_NE(text.size(), u16text.size());
  paragraph_builder.AddText(reinterpret_cast<const uint8_t*>(text.data()),
                            text.size());
  hpp::DisplayListBuilder builder;
  // Don't rely on implicit line breaks in this test to make it less brittle to
  // different fonts being picked.
  hpp::Paragraph paragraph = paragraph_builder.Build(FLT_MAX);
  const auto line_count = paragraph.GetLineCount();
  ASSERT_EQ(line_count, 4u);
 
  // Line Metrics.
  {
    auto metrics = paragraph.GetLineMetrics();
    ASSERT_GT(metrics.GetAscent(0), 0.0);
    ASSERT_GT(metrics.GetUnscaledAscent(0), 0.0);
    ASSERT_GT(metrics.GetDescent(0), 0.0);
    ASSERT_GT(metrics.GetBaseline(0), 0.0);
    ASSERT_TRUE(metrics.IsHardbreak(0));
    ASSERT_DOUBLE_EQ(metrics.GetLeft(0), 0.0);
    ASSERT_EQ(metrics.GetCodeUnitStartIndex(0), 0u);
    ASSERT_EQ(metrics.GetCodeUnitEndIndexIncludingNewline(0),
              metrics.GetCodeUnitEndIndex(0) + 1u);
    ASSERT_GT(metrics.GetCodeUnitStartIndex(1), 0u);
    // Last line should cover the entire range.
    ASSERT_EQ(metrics.GetCodeUnitEndIndex(3), u16text.size());
  }
 
  // Glyph info by code point.
  {
    auto glyph = paragraph.GlyphInfoAtCodeUnitIndex(0u);
    ASSERT_TRUE(glyph);
    ASSERT_EQ(glyph.GetGraphemeClusterCodeUnitRangeBegin(), 0u);
    ASSERT_EQ(glyph.GetGraphemeClusterCodeUnitRangeEnd(),
              fml::Utf8ToUtf16("🏁").size());
    auto bounds = glyph.GetGraphemeClusterBounds();
    ASSERT_GT(bounds.width, 0.0);
    ASSERT_GT(bounds.height, 0.0);
    ASSERT_FALSE(glyph.IsEllipsis());
    ASSERT_EQ(glyph.GetTextDirection(), kImpellerTextDirectionLTR);
 
    ImpellerRect bounds2 = {};
    ImpellerGlyphInfoGetGraphemeClusterBounds(glyph.Get(), &bounds2);
    ASSERT_EQ(bounds.width, bounds2.width);
    ASSERT_EQ(bounds.height, bounds2.height);
  }
 
  // Glyph info by coordinates.
  {
    auto glyph = paragraph.GlyphInfoAtParagraphCoordinates(0.0, 0.0);
    ASSERT_TRUE(glyph);
    ASSERT_EQ(glyph.GetGraphemeClusterCodeUnitRangeEnd(),
              fml::Utf8ToUtf16("🏁").size());
  }
 
  // Glyph Figure out word boundaries.
  {
    auto glyph = paragraph.GlyphInfoAtCodeUnitIndex(0u);
    ASSERT_TRUE(glyph);
    auto range =
        paragraph.GetWordBoundary(glyph.GetGraphemeClusterCodeUnitRangeEnd());
    ASSERT_GT(range.end, 0u);
    ImpellerRange range2 = {};
    ImpellerParagraphGetWordBoundary(
        paragraph.Get(), glyph.GetGraphemeClusterCodeUnitRangeEnd(), &range2);
    ASSERT_EQ(range.start, range2.start);
    ASSERT_EQ(range.end, range2.end);
  }
 
  builder.DrawParagraph(paragraph, ImpellerPoint{100, 100});
  auto dl = builder.Build();
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        hpp::Surface window(surface.GetC());
        window.Draw(dl);
        return true;
      }));
}

References context, ImpellerRange::end, ImpellerRect::height, impeller::interop::ImpellerGlyphInfoGetGraphemeClusterBounds(), impeller::interop::ImpellerParagraphGetWordBoundary(), kImpellerTextDirectionLTR, ImpellerRange::start, surface, text, fml::Utf8ToUtf16(), ImpellerRect::width, and window.

TEST_P() [15/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanRenderShadows
	)

Definition at line 509 of file impeller_unittests.cc.

                                                {
  hpp::DisplayListBuilder builder;
  {
    builder.DrawRect(ImpellerRect{0, 0, 400, 400},
                     hpp::Paint{}.SetColor(ImpellerColor{
                         0.0, 1.0, 0.0, 1.0, kImpellerColorSpaceSRGB}));
  }
  ImpellerRect box = {100, 100, 100, 100};
  {
    hpp::PathBuilder path_builder;
    path_builder.AddRect(box);
    ImpellerColor shadow_color = {0.0, 0.0, 0.0, 1.0, kImpellerColorSpaceSRGB};
    builder.DrawShadow(path_builder.Build(), shadow_color, 4.0f, false, 1.0f);
  }
  {
    hpp::Paint red_paint;
    red_paint.SetColor(
        ImpellerColor{1.0, 0.0, 0.0, 1.0, kImpellerColorSpaceSRGB});
    builder.DrawRect(box, red_paint);
  }
  auto dl = builder.Build();
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        hpp::Surface window(surface.GetC());
        window.Draw(dl);
        return true;
      }));
}

References context, kImpellerColorSpaceSRGB, surface, and window.

TEST_P() [16/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		CanRenderTextAlignments
	)

Definition at line 470 of file impeller_unittests.cc.

                                                       {
  hpp::TypographyContext tc;
 
  hpp::DisplayListBuilder builder;
  hpp::Paint bg;
  hpp::ParagraphStyle p_style;
  p_style.SetFontFamily("Roboto");
  p_style.SetFontSize(24.0);
  p_style.SetFontWeight(kImpellerFontWeight400);
 
  // Clear the background to a white color.
  ImpellerColor clear_color = {1.0, 1.0, 1.0, 1.0};
  bg.SetColor(clear_color);
  builder.DrawPaint(bg);
 
  // Draw red, left-aligned text.
  ImpellerColor red = {1.0, 0.0, 0.0, 1.0};
  DrawTextFrame(tc, builder, p_style, bg, red, kImpellerTextAlignmentLeft, 0.0);
 
  // Draw green, centered text.
  ImpellerColor green = {0.0, 1.0, 0.0, 1.0};
  DrawTextFrame(tc, builder, p_style, bg, green, kImpellerTextAlignmentCenter,
                220.0);
 
  // Draw blue, right-aligned text.
  ImpellerColor blue = {0.0, 0.0, 1.0, 1.0};
  DrawTextFrame(tc, builder, p_style, bg, blue, kImpellerTextAlignmentRight,
                440.0);
 
  auto dl = builder.Build();
 
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        hpp::Surface window(surface.GetC());
        window.Draw(dl);
        return true;
      }));
}

References context, DrawTextFrame(), kImpellerFontWeight400, kImpellerTextAlignmentCenter, kImpellerTextAlignmentLeft, kImpellerTextAlignmentRight, surface, and window.

TEST_P() [17/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		ClearsOpenGLStancilStateAfterTransition
	)

Definition at line 204 of file impeller_unittests.cc.

                                                                       {
  auto context = GetInteropContext();
  auto impeller_context = context->GetContext();
  if (impeller_context->GetBackendType() !=
      impeller::Context::BackendType::kOpenGLES) {
    GTEST_SKIP() << "This test works with OpenGL handles is only suitable for "
                    "that backend.";
    return;
  }
  const auto& gl_context = ContextGLES::Cast(*impeller_context);
  const auto& gl = gl_context.GetReactor()->GetProcTable();
  auto builder =
      Adopt<DisplayListBuilder>(ImpellerDisplayListBuilderNew(nullptr));
  auto paint = Adopt<Paint>(ImpellerPaintNew());
  ImpellerColor color = {0.0, 0.0, 1.0, 1.0};
  ImpellerPaintSetColor(paint.GetC(), &color);
  ImpellerRect rect = {10, 20, 100, 200};
  ImpellerDisplayListBuilderDrawRect(builder.GetC(), &rect, paint.GetC());
  color = {1.0, 0.0, 0.0, 1.0};
  ImpellerPaintSetColor(paint.GetC(), &color);
  ImpellerDisplayListBuilderTranslate(builder.GetC(), 110, 210);
  ImpellerDisplayListBuilderClipRect(builder.GetC(), &rect,
                                     kImpellerClipOperationDifference);
  ImpellerDisplayListBuilderDrawRect(builder.GetC(), &rect, paint.GetC());
  auto dl = Adopt<DisplayList>(
      ImpellerDisplayListBuilderCreateDisplayListNew(builder.GetC()));
  ASSERT_TRUE(dl);
  ASSERT_TRUE(
      OpenPlaygroundHere([&](const auto& context, const auto& surface) -> bool {
        ImpellerSurfaceDrawDisplayList(surface.GetC(), dl.GetC());
        // OpenGL state is reset even though the operations above enable a
        // stencil check.
        GLboolean stencil_enabled = true;
        gl.GetBooleanv(GL_STENCIL_TEST, &stencil_enabled);
        return stencil_enabled == GL_FALSE;
      }));
}

References impeller::BackendCast< ContextGLES, Context >::Cast(), context, impeller::interop::ImpellerDisplayListBuilderClipRect(), impeller::interop::ImpellerDisplayListBuilderCreateDisplayListNew(), impeller::interop::ImpellerDisplayListBuilderDrawRect(), impeller::interop::ImpellerDisplayListBuilderNew(), impeller::interop::ImpellerDisplayListBuilderTranslate(), impeller::interop::ImpellerPaintNew(), impeller::interop::ImpellerPaintSetColor(), impeller::interop::ImpellerSurfaceDrawDisplayList(), kImpellerClipOperationDifference, impeller::Context::kOpenGLES, and surface.

TEST_P() [18/18]

impeller::interop::testing::TEST_P	(	InteropPlaygroundTest	,
		MappingsReleaseTheirDataOnDestruction
	)

Definition at line 696 of file impeller_unittests.cc.

                                                                     {
  bool deleted = false;
  {
    hpp::Mapping mapping(nullptr, 0, [&deleted]() { deleted = true; });
  }
  ASSERT_TRUE(deleted);
}