fontimage.h

Go to the documentation of this file.

#ifndef ION_TEXT_FONTIMAGE_H_
#define ION_TEXT_FONTIMAGE_H_

#include <algorithm>
#include <memory>
#include <vector>

#include "ion/base/allocator.h"
#include "ion/base/invalid.h"
#include "ion/base/readwritelock.h"
#include "ion/base/referent.h"
#include "ion/base/stlalloc/allocmap.h"
#include "ion/base/stlalloc/allocset.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/gfx/image.h"
#include "ion/gfx/texture.h"
#include "ion/math/range.h"
#include "ion/text/font.h"

namespace ion {
namespace text {

class BinPacker;




class FontImage : public base::Referent {
 public:
  enum Type {
    kStatic,
    kDynamic,
  };

  struct ImageData {
    explicit ImageData(const base::AllocatorPtr& allocator);
    gfx::TexturePtr texture;
    GlyphSet glyph_set;
    typedef base::AllocMap<GlyphIndex, math::Range2f> TexRectMap;
    TexRectMap texture_rectangle_map;
    typedef base::AllocVector<gfx::Texture::SubImage> SubImageVec;
  };

  Type GetType() const { return type_; }

  const FontPtr& GetFont() { return font_; }

  size_t GetMaxImageSize() { return max_image_size_; }

  virtual const ImageData& FindImageData(const GlyphSet& glyph_set) = 0;

  static bool HasAllGlyphs(const ImageData& image_data,
                           const GlyphSet& glyph_set) {
    const auto& iglyphs = image_data.glyph_set;
    return !base::IsInvalidReference(image_data) &&
           std::includes(iglyphs.cbegin(), iglyphs.cend(), glyph_set.cbegin(),
                         glyph_set.cend());
  }

  static bool HasGlyph(const ImageData& image_data, GlyphIndex glyph_index) {
    return !base::IsInvalidReference(image_data) &&
           image_data.glyph_set.count(glyph_index);
  }

  static bool GetTextureCoords(const ImageData& image_data,
                               GlyphIndex glyph_index,
                               math::Range2f* rectangle);

 protected:
  FontImage(Type type, const FontPtr& font, size_t max_image_size);

  ~FontImage() override;

 private:
  const Type type_;
  FontPtr font_;
  const size_t max_image_size_;
};

typedef base::ReferentPtr<FontImage>::Type FontImagePtr;




class StaticFontImage : public FontImage {
 public:
  StaticFontImage(const FontPtr& font, size_t max_image_size,
                  const GlyphSet& glyph_set);

  const ImageData& GetImageData() const { return image_data_; }

  const ImageData& FindImageData(const GlyphSet& glyph_sets) override;

 protected:
  StaticFontImage(const FontPtr& font, size_t max_image_size,
                  const ImageData& image_data);
  ~StaticFontImage() override;

 private:
  const ImageData InitImageData(const std::string& texture_name,
                                const GlyphSet& glyph_set);

  const ImageData image_data_;
};

typedef base::ReferentPtr<StaticFontImage>::Type StaticFontImagePtr;




class DynamicFontImage : public FontImage {
 public:
  DynamicFontImage(const FontPtr& font, size_t image_size);

  size_t GetImageDataCount() const;

  const ImageData& GetImageData(size_t index) const;

  float GetImageDataUsedAreaFraction(size_t index) const;

  void EnableDeferredUpdates(bool enable) { updates_deferred_ = enable; }

  bool AreUpdatesDeferred() const { return updates_deferred_; }

  void ProcessDeferredUpdates();

  const ImageData& FindImageData(const GlyphSet& glyph_set) override;

  size_t FindImageDataIndex(const GlyphSet& glyph_set);

  size_t FindContainingImageDataIndex(const GlyphSet& glyph_set);

 protected:
  ~DynamicFontImage() override;

 private:
  class Helper;

  size_t FindContainingImageDataIndexPrefiltered(const GlyphSet& glyph_set);

  size_t FindImageDataThatFits(const GlyphSet& glyph_set);

  size_t AddImageData(const GlyphSet& glyph_set);

  std::unique_ptr<Helper> helper_;

  bool updates_deferred_;

  base::ReadWriteLock update_lock_;
};

typedef base::ReferentPtr<DynamicFontImage>::Type DynamicFontImagePtr;

}  // namespace text
}  // namespace ion

#endif  // ION_TEXT_FONTIMAGE_H_