impeller::TypographerContextSkia Class Reference

#include <typographer_context_skia.h>

Inheritance diagram for impeller::TypographerContextSkia:

Public Member Functions
	TypographerContextSkia ()
	~TypographerContextSkia () override
std::shared_ptr< GlyphAtlasContext >	CreateGlyphAtlasContext (GlyphAtlas::Type type) const override
std::shared_ptr< GlyphAtlas >	CreateGlyphAtlas (Context &context, GlyphAtlas::Type type, HostBuffer &host_buffer, const std::shared_ptr< GlyphAtlasContext > &atlas_context, const std::vector< RenderableText > &renderable_texts) const override
Public Member Functions inherited from impeller::TypographerContext
virtual	~TypographerContext ()
virtual bool	IsValid () const

Static Public Member Functions
static std::shared_ptr< TypographerContext >	Make ()

Additional Inherited Members
Protected Member Functions inherited from impeller::TypographerContext
	TypographerContext ()
	Create a new context to render text that talks to an underlying graphics context. More...

Detailed Description

Definition at line 12 of file typographer_context_skia.h.

Constructor & Destructor Documentation

TypographerContextSkia()

impeller::TypographerContextSkia::TypographerContextSkia ( )

default

~TypographerContextSkia()

impeller::TypographerContextSkia::~TypographerContextSkia ( )

overridedefault

Member Function Documentation

CreateGlyphAtlas()

std::shared_ptr< GlyphAtlas > impeller::TypographerContextSkia::CreateGlyphAtlas ( Context &  context, GlyphAtlas::Type  type, HostBuffer &  host_buffer, const std::shared_ptr< GlyphAtlasContext > &  atlas_context, const std::vector< RenderableText > &  renderable_texts  ) const

overridevirtual

Implements impeller::TypographerContext.

Definition at line 482 of file typographer_context_skia.cc.

                                                             {
  TRACE_EVENT0("impeller", __FUNCTION__);
  if (!IsValid()) {
    return nullptr;
  }
  std::shared_ptr<GlyphAtlas> last_atlas = atlas_context->GetGlyphAtlas();
  FML_DCHECK(last_atlas->GetType() == type);
 
  if (renderable_texts.empty()) {
    return last_atlas;
  }
 
  // ---------------------------------------------------------------------------
  // Step 1: Determine if the atlas type and font glyph pairs are compatible
  //         with the current atlas and reuse if possible. For each new font and
  //         glyph pair, compute the glyph size at scale.
  // ---------------------------------------------------------------------------
  auto [new_glyphs, glyph_sizes] =
      CollectNewGlyphs(last_atlas, renderable_texts);
  if (new_glyphs.size() == 0) {
    return last_atlas;
  }
 
  // ---------------------------------------------------------------------------
  // Step 2: Determine if the additional missing glyphs can be appended to the
  //         existing bitmap without recreating the atlas.
  // ---------------------------------------------------------------------------
  std::vector<Rect> glyph_positions;
  glyph_positions.reserve(new_glyphs.size());
  size_t first_missing_index = 0;
 
  if (last_atlas->GetTexture()) {
    // Append all glyphs that fit into the current atlas.
    first_missing_index = AppendToExistingAtlas(
        last_atlas, new_glyphs, glyph_positions, glyph_sizes,
        atlas_context->GetAtlasSize(), atlas_context->GetHeightAdjustment(),
        atlas_context->GetRectPacker());
 
    // ---------------------------------------------------------------------------
    // Step 3a: Record the positions in the glyph atlas of the newly added
    //          glyphs.
    // ---------------------------------------------------------------------------
    for (size_t i = 0; i < first_missing_index; i++) {
      last_atlas->AddTypefaceGlyphPositionAndBounds(
          new_glyphs[i], glyph_positions[i], glyph_sizes[i]);
    }
 
    std::shared_ptr<CommandBuffer> cmd_buffer = context.CreateCommandBuffer();
    std::shared_ptr<BlitPass> blit_pass = cmd_buffer->CreateBlitPass();
 
    fml::ScopedCleanupClosure closure([&]() {
      blit_pass->EncodeCommands();
      if (!context.EnqueueCommandBuffer(std::move(cmd_buffer))) {
        VALIDATION_LOG << "Failed to submit glyph atlas command buffer";
      }
    });
 
    // ---------------------------------------------------------------------------
    // Step 4a: Draw new font-glyph pairs into the a host buffer and encode
    // the uploads into the blit pass.
    // ---------------------------------------------------------------------------
    if (!UpdateAtlasBitmap(*last_atlas, blit_pass, data_host_buffer,
                           last_atlas->GetTexture(), new_glyphs, 0,
                           first_missing_index)) {
      return nullptr;
    }
 
    // If all glyphs fit, just return the old atlas.
    if (first_missing_index == new_glyphs.size()) {
      return last_atlas;
    }
  }
 
  int64_t height_adjustment = atlas_context->GetAtlasSize().height;
  const int64_t max_texture_height =
      context.GetResourceAllocator()->GetMaxTextureSizeSupported().height;
 
  // IF the current atlas size is as big as it can get, then "GC" and create an
  // atlas with only the required glyphs. OpenGLES cannot reliably perform the
  // blit required here, as 1) it requires attaching textures as read and write
  // framebuffers which has substantially smaller size limits that max textures
  // and 2) is missing a GLES 2.0 implementation and cap check.
  bool blit_old_atlas = true;
  std::shared_ptr<GlyphAtlas> new_atlas = last_atlas;
  if (atlas_context->GetAtlasSize().height >= max_texture_height ||
      context.GetBackendType() == Context::BackendType::kOpenGLES) {
    blit_old_atlas = false;
    new_atlas = std::make_shared<GlyphAtlas>(
        type, /*initial_generation=*/last_atlas->GetAtlasGeneration() + 1);
 
    auto [update_glyphs, update_sizes] =
        CollectNewGlyphs(new_atlas, renderable_texts);
    new_glyphs = std::move(update_glyphs);
    glyph_sizes = std::move(update_sizes);
 
    glyph_positions.clear();
    glyph_positions.reserve(new_glyphs.size());
    first_missing_index = 0;
 
    height_adjustment = 0;
    atlas_context->UpdateRectPacker(nullptr);
    atlas_context->UpdateGlyphAtlas(new_atlas, {0, 0}, 0);
  }
 
  // A new glyph atlas must be created.
  ISize atlas_size = ComputeNextAtlasSize(atlas_context,        //
                                          new_glyphs,           //
                                          glyph_positions,      //
                                          glyph_sizes,          //
                                          first_missing_index,  //
                                          max_texture_height    //
  );
 
  atlas_context->UpdateGlyphAtlas(new_atlas, atlas_size, height_adjustment);
  if (atlas_size.IsEmpty()) {
    return nullptr;
  }
  FML_DCHECK(new_glyphs.size() == glyph_positions.size());
 
  TextureDescriptor descriptor;
  switch (type) {
    case GlyphAtlas::Type::kAlphaBitmap:
      descriptor.format =
          context.GetCapabilities()->GetDefaultGlyphAtlasFormat();
      break;
    case GlyphAtlas::Type::kColorBitmap:
      descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
      break;
  }
  descriptor.size = atlas_size;
  descriptor.storage_mode = StorageMode::kDevicePrivate;
  descriptor.usage = TextureUsage::kShaderRead;
  std::shared_ptr<Texture> new_texture =
      context.GetResourceAllocator()->CreateTexture(descriptor);
  if (!new_texture) {
    return nullptr;
  }
 
  new_texture->SetLabel("GlyphAtlas");
 
  std::shared_ptr<CommandBuffer> cmd_buffer = context.CreateCommandBuffer();
  std::shared_ptr<BlitPass> blit_pass = cmd_buffer->CreateBlitPass();
 
  fml::ScopedCleanupClosure closure([&]() {
    blit_pass->EncodeCommands();
    if (!context.EnqueueCommandBuffer(std::move(cmd_buffer))) {
      VALIDATION_LOG << "Failed to submit glyph atlas command buffer";
    }
  });
 
  // Now append all remaining glyphs. This should never have any missing data...
  auto old_texture = new_atlas->GetTexture();
  new_atlas->SetTexture(std::move(new_texture));
 
  // ---------------------------------------------------------------------------
  // Step 3a: Record the positions in the glyph atlas of the newly added
  //          glyphs.
  // ---------------------------------------------------------------------------
  for (size_t i = first_missing_index; i < glyph_positions.size(); i++) {
    new_atlas->AddTypefaceGlyphPositionAndBounds(
        new_glyphs[i], glyph_positions[i], glyph_sizes[i]);
  }
 
  // ---------------------------------------------------------------------------
  // Step 4a: Draw new font-glyph pairs into the a host buffer and encode
  // the uploads into the blit pass.
  // ---------------------------------------------------------------------------
  if (!BulkUpdateAtlasBitmap(*new_atlas, blit_pass, data_host_buffer,
                             new_atlas->GetTexture(), new_glyphs,
                             first_missing_index, new_glyphs.size())) {
    return nullptr;
  }
 
  // Blit the old texture to the top left of the new atlas.
  if (blit_old_atlas && old_texture) {
    blit_pass->AddCopy(old_texture, new_atlas->GetTexture(),
                       IRect::MakeSize(new_atlas->GetTexture()->GetSize()),
                       {0, 0});
  }
 
  // ---------------------------------------------------------------------------
  // Step 8b: Record the texture in the glyph atlas.
  // ---------------------------------------------------------------------------
 
  return new_atlas;
}

References impeller::AppendToExistingAtlas(), impeller::BulkUpdateAtlasBitmap(), impeller::ComputeNextAtlasSize(), impeller::Context::CreateCommandBuffer(), impeller::Context::EnqueueCommandBuffer(), impeller::TextureDescriptor::format, impeller::Context::GetBackendType(), impeller::Context::GetCapabilities(), impeller::Context::GetResourceAllocator(), impeller::TSize< T >::IsEmpty(), impeller::TypographerContext::IsValid(), impeller::GlyphAtlas::kAlphaBitmap, impeller::GlyphAtlas::kColorBitmap, impeller::kDevicePrivate, impeller::Context::kOpenGLES, impeller::kR8G8B8A8UNormInt, impeller::kShaderRead, impeller::TRect< T >::MakeSize(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::UpdateAtlasBitmap(), and impeller::TextureDescriptor::usage.

CreateGlyphAtlasContext()

std::shared_ptr< GlyphAtlasContext > impeller::TypographerContextSkia::CreateGlyphAtlasContext ( GlyphAtlas::Type  type ) const

overridevirtual

Implements impeller::TypographerContext.

Definition at line 85 of file typographer_context_skia.cc.

                                                                         {
  return std::make_shared<GlyphAtlasContext>(type);
}

Make()

std::shared_ptr< TypographerContext > impeller::TypographerContextSkia::Make ( )

static

Definition at line 76 of file typographer_context_skia.cc.

                                                               {
  return std::make_shared<TypographerContextSkia>();
}

Referenced by impeller::DlPlayground::OpenPlaygroundHere(), and impeller::testing::TEST_P().

---

The documentation for this class was generated from the following files:

• impeller/typographer/backends/skia/typographer_context_skia.h
• impeller/typographer/backends/skia/typographer_context_skia.cc