impeller::TypographerContextSTB Class Reference

#include <typographer_context_stb.h>

Inheritance diagram for impeller::TypographerContextSTB:

Public Member Functions
	TypographerContextSTB ()
	~TypographerContextSTB () 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 FontGlyphMap &font_glyph_map) const override
Public Member Functions inherited from impeller::TypographerContext
virtual	~TypographerContext ()
virtual bool	IsValid () const

Static Public Member Functions
static std::unique_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 15 of file typographer_context_stb.h.

Constructor & Destructor Documentation

TypographerContextSTB()

impeller::TypographerContextSTB::TypographerContextSTB

(

)

Definition at line 36 of file typographer_context_stb.cc.

: TypographerContext() {}

~TypographerContextSTB()

impeller::TypographerContextSTB::~TypographerContextSTB ( )

overridedefault

Member Function Documentation

CreateGlyphAtlas()

std::shared_ptr< GlyphAtlas > impeller::TypographerContextSTB::CreateGlyphAtlas ( Context &  context, GlyphAtlas::Type  type, HostBuffer &  host_buffer, const std::shared_ptr< GlyphAtlasContext > &  atlas_context, const FontGlyphMap &  font_glyph_map  ) const

overridevirtual

Implements impeller::TypographerContext.

Definition at line 399 of file typographer_context_stb.cc.

                                              {
  TRACE_EVENT0("impeller", __FUNCTION__);
  if (!IsValid()) {
    return nullptr;
  }
  auto& atlas_context_stb = GlyphAtlasContextSTB::Cast(*atlas_context);
  std::shared_ptr<GlyphAtlas> last_atlas = atlas_context->GetGlyphAtlas();
 
  if (font_glyph_map.empty()) {
    return last_atlas;
  }
 
  std::shared_ptr<CommandBuffer> cmd_buffer = context.CreateCommandBuffer();
  std::shared_ptr<BlitPass> blit_pass = cmd_buffer->CreateBlitPass();
 
  fml::ScopedCleanupClosure closure([&cmd_buffer, &context]() {
    context.GetCommandQueue()->Submit({std::move(cmd_buffer)});
  });
 
  // ---------------------------------------------------------------------------
  // Step 1: Determine if the atlas type and font glyph pairs are compatible
  //         with the current atlas and reuse if possible.
  // ---------------------------------------------------------------------------
  std::vector<FontGlyphPair> new_glyphs;
  std::vector<Rect> new_sizes;
  for (const auto& font_value : font_glyph_map) {
    const ScaledFont& scaled_font = font_value.first;
    const FontGlyphAtlas* font_glyph_atlas =
        last_atlas->GetFontGlyphAtlas(scaled_font.font, scaled_font.scale);
    if (font_glyph_atlas) {
      for (const SubpixelGlyph& glyph : font_value.second) {
        if (!font_glyph_atlas->FindGlyphBounds(glyph)) {
          new_glyphs.emplace_back(scaled_font, glyph);
          new_sizes.push_back(ComputeGlyphSize(scaled_font, glyph));
        }
      }
    } else {
      for (const SubpixelGlyph& glyph : font_value.second) {
        new_glyphs.emplace_back(scaled_font, glyph);
        new_sizes.push_back(ComputeGlyphSize(scaled_font, glyph));
      }
    }
  }
  if (last_atlas->GetType() == type && 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. This requires that
  //         the type is identical.
  // ---------------------------------------------------------------------------
  std::vector<Rect> glyph_positions;
  if (last_atlas->GetType() == type &&
      CanAppendToExistingAtlas(last_atlas, new_glyphs, glyph_positions,
                               atlas_context->GetAtlasSize(),
                               atlas_context->GetRectPacker())) {
    // The old bitmap will be reused and only the additional glyphs will be
    // added.
 
    // ---------------------------------------------------------------------------
    // Step 3a: Record the positions in the glyph atlas of the newly added
    // glyphs.
    // ---------------------------------------------------------------------------
    for (size_t i = 0, count = glyph_positions.size(); i < count; i++) {
      last_atlas->AddTypefaceGlyphPositionAndBounds(
          new_glyphs[i], glyph_positions[i], new_sizes[i]);
    }
 
    // ---------------------------------------------------------------------------
    // Step 4a: Draw new font-glyph pairs into the existing bitmap.
    // ---------------------------------------------------------------------------
    // auto bitmap = atlas_context->GetBitmap();
    auto bitmap = atlas_context_stb.GetBitmap();
    if (!UpdateAtlasBitmap(*last_atlas, bitmap, new_glyphs)) {
      return nullptr;
    }
 
    // ---------------------------------------------------------------------------
    // Step 5a: Update the existing texture with the updated bitmap.
    // ---------------------------------------------------------------------------
    if (!UpdateGlyphTextureAtlas(bitmap, context.GetResourceAllocator(),
                                 blit_pass, last_atlas->GetTexture())) {
      return nullptr;
    }
    return last_atlas;
  }
  // A new glyph atlas must be created.
 
  // ---------------------------------------------------------------------------
  // Step 3b: Get the optimum size of the texture atlas.
  // ---------------------------------------------------------------------------
  std::vector<FontGlyphPair> font_glyph_pairs;
  font_glyph_pairs.reserve(std::accumulate(
      font_glyph_map.begin(), font_glyph_map.end(), 0,
      [](const int a, const auto& b) { return a + b.second.size(); }));
  for (const auto& font_value : font_glyph_map) {
    const ScaledFont& scaled_font = font_value.first;
    for (const SubpixelGlyph& glyph : font_value.second) {
      font_glyph_pairs.push_back({scaled_font, glyph});
    }
  }
  auto glyph_atlas = std::make_shared<GlyphAtlas>(type);
  auto atlas_size = OptimumAtlasSizeForFontGlyphPairs(
      font_glyph_pairs,                                             //
      glyph_positions,                                              //
      atlas_context,                                                //
      type,                                                         //
      context.GetResourceAllocator()->GetMaxTextureSizeSupported()  //
  );
 
  atlas_context->UpdateGlyphAtlas(glyph_atlas, atlas_size, 0);
  if (atlas_size.IsEmpty()) {
    return nullptr;
  }
 
  // ---------------------------------------------------------------------------
  // Step 4b: Find location of font-glyph pairs in the atlas. We have this from
  // the last step. So no need to do create another rect packer. But just do a
  // sanity check of counts. This could also be just an assertion as only a
  // construction issue would cause such a failure.
  // ---------------------------------------------------------------------------
  if (glyph_positions.size() != font_glyph_pairs.size()) {
    return nullptr;
  }
 
  // ---------------------------------------------------------------------------
  // Step 5b: Record the positions in the glyph atlas.
  // ---------------------------------------------------------------------------
  {
    size_t i = 0;
    for (auto it = font_glyph_pairs.begin(); it != font_glyph_pairs.end();
         ++i, ++it) {
      glyph_atlas->AddTypefaceGlyphPositionAndBounds(*it, glyph_positions[i],
                                                     new_sizes[i]);
    }
  }
 
  // ---------------------------------------------------------------------------
  // Step 6b: Draw font-glyph pairs in the correct spot in the atlas.
  // ---------------------------------------------------------------------------
  auto bitmap = CreateAtlasBitmap(*glyph_atlas, atlas_size);
  if (!bitmap) {
    return nullptr;
  }
  atlas_context_stb.UpdateBitmap(bitmap);
 
  // ---------------------------------------------------------------------------
  // Step 7b: Upload the atlas as a texture.
  // ---------------------------------------------------------------------------
  PixelFormat format;
  switch (type) {
    case GlyphAtlas::Type::kAlphaBitmap:
      format = context.GetCapabilities()->GetDefaultGlyphAtlasFormat();
      break;
    case GlyphAtlas::Type::kColorBitmap:
      format = DISABLE_COLOR_FONT_SUPPORT
                   ? context.GetCapabilities()->GetDefaultGlyphAtlasFormat()
                   : PixelFormat::kR8G8B8A8UNormInt;
      break;
  }
  auto texture = UploadGlyphTextureAtlas(context.GetResourceAllocator(),
                                         blit_pass, bitmap, atlas_size, format);
  if (!texture) {
    return nullptr;
  }
 
  // ---------------------------------------------------------------------------
  // Step 8b: Record the texture in the glyph atlas.
  // ---------------------------------------------------------------------------
  glyph_atlas->SetTexture(std::move(texture));
 
  return glyph_atlas;
}

References impeller::saturated::b, impeller::CanAppendToExistingAtlas(), impeller::BackendCast< GlyphAtlasContextSTB, GlyphAtlasContext >::Cast(), impeller::ComputeGlyphSize(), impeller::CreateAtlasBitmap(), impeller::Context::CreateCommandBuffer(), DISABLE_COLOR_FONT_SUPPORT, impeller::FontGlyphAtlas::FindGlyphBounds(), impeller::ScaledFont::font, impeller::Context::GetCapabilities(), impeller::Context::GetCommandQueue(), impeller::Context::GetResourceAllocator(), impeller::TypographerContext::IsValid(), impeller::GlyphAtlas::kAlphaBitmap, impeller::GlyphAtlas::kColorBitmap, impeller::kR8G8B8A8UNormInt, impeller::OptimumAtlasSizeForFontGlyphPairs(), impeller::ScaledFont::scale, type, impeller::UpdateAtlasBitmap(), impeller::UpdateGlyphTextureAtlas(), and impeller::UploadGlyphTextureAtlas().

CreateGlyphAtlasContext()

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

overridevirtual

Implements impeller::TypographerContext.

Definition at line 41 of file typographer_context_stb.cc.

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

References type.

Make()

std::unique_ptr< TypographerContext > impeller::TypographerContextSTB::Make ( )

static

Definition at line 32 of file typographer_context_stb.cc.

                                                              {
  return std::make_unique<TypographerContextSTB>();
}

Referenced by impeller::testing::TEST_P().

---

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

• impeller/typographer/backends/stb/typographer_context_stb.h
• impeller/typographer/backends/stb/typographer_context_stb.cc