gfx_layout.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef GFX_LAYOUT_H
#define GFX_LAYOUT_H
 
#include "misc/lrucache.hpp"
#include "fontcache.h"
#include "gfx_func.h"
#include "core/math_func.hpp"
 
#include <string_view>
 
struct FontState {
  FontSize fontsize;       
  TextColour cur_colour;   
  std::vector<TextColour> colour_stack; 
 
  FontState() : fontsize(FS_END), cur_colour(TC_INVALID) {}
  FontState(TextColour colour, FontSize fontsize) : fontsize(fontsize), cur_colour(colour) {}
 
  auto operator<=>(const FontState &) const = default;
 
  inline void SetColour(TextColour c)
  {
    assert(((c & TC_COLOUR_MASK) >= TC_BLUE && (c & TC_COLOUR_MASK) <= TC_BLACK) || (c & TC_COLOUR_MASK) == TC_INVALID);
    assert((c & (TC_COLOUR_MASK | TC_FLAGS_MASK)) == c);
    if ((this->cur_colour & TC_FORCED) == 0) this->cur_colour = c;
  }
  inline void SetColour(TextColour c) {…}
 
  inline void PopColour()
  {
    if (colour_stack.empty()) return;
    SetColour(colour_stack.back());
    colour_stack.pop_back();
  }
  inline void PopColour() {…}
 
  inline void PushColour()
  {
    colour_stack.push_back(this->cur_colour);
  }
  inline void PushColour() {…}
 
  inline void SetFontSize(FontSize f)
  {
    this->fontsize = f;
  }
  inline void SetFontSize(FontSize f) {…}
};
struct FontState {…};
 
template <typename T> struct std::hash<std::vector<T>> {
  size_t operator()(const std::vector<T> &vec) const
  {
    /* This is not an optimal hash algorithm but in most cases this is empty and therefore the same anyway. */
    return std::transform_reduce(std::begin(vec), std::end(vec),
      std::hash<size_t>{}(std::size(vec)),
      [](const size_t &a, const size_t &b) -> size_t { return a ^ b; },
      [](const T &x) -> size_t { return std::hash<T>{}(x); });
  }
};
template <typename T> struct std::hash<std::vector<T>> {…};
 
template <> struct std::hash<FontState> {
  std::size_t operator()(const FontState &state) const noexcept
  {
    size_t h1 = std::hash<FontSize>{}(state.fontsize);
    size_t h2 = std::hash<TextColour>{}(state.cur_colour);
    size_t h3 = std::hash<std::vector<TextColour>>{}(state.colour_stack);
    return h1 ^ (h2 << 1) ^ (h3 << 2);
  }
};
template <> struct std::hash<FontState> {…};
 
class Font {
public:
  FontCache *fc;     
  TextColour colour; 
 
  Font(FontSize size, TextColour colour);
};
class Font {…};
 
using FontMap = std::vector<std::pair<int, Font *>>;
 
class ParagraphLayouter {
public:
  virtual ~ParagraphLayouter() = default;
 
  class Position {
  public:
    int16_t left; 
    int16_t right; 
    int16_t top; 
 
    constexpr inline Position(int16_t left, int16_t right, int16_t top) : left(left), right(right), top(top) { }
 
    constexpr inline Position(const Point &pt) : left(pt.x), right(pt.x), top(pt.y) { }
  };
  class Position {…};
 
  class VisualRun {
  public:
    virtual ~VisualRun() = default;
    virtual const Font *GetFont() const = 0;
    virtual int GetGlyphCount() const = 0;
    virtual std::span<const GlyphID> GetGlyphs() const = 0;
    virtual std::span<const Position> GetPositions() const = 0;
    virtual int GetLeading() const = 0;
    virtual std::span<const int> GetGlyphToCharMap() const = 0;
  };
  class VisualRun {…};
 
  class Line {
  public:
    virtual ~Line() = default;
    virtual int GetLeading() const = 0;
    virtual int GetWidth() const = 0;
    virtual int CountRuns() const = 0;
    virtual const VisualRun &GetVisualRun(int run) const = 0;
    virtual int GetInternalCharLength(char32_t c) const = 0;
  };
  class Line {…};
 
  virtual void Reflow() = 0;
  virtual std::unique_ptr<const Line> NextLine(int max_width) = 0;
};
class ParagraphLayouter {…};
 
class Layouter : public std::vector<const ParagraphLayouter::Line *> {
  std::string_view string; 
 
  struct LineCacheKey {
    FontState state_before;  
    std::string str;         
  };
  struct LineCacheKey {…};
 
  struct LineCacheQuery {
    const FontState &state_before; 
    std::string_view str;    
  };
  struct LineCacheQuery {…};
 
  friend struct std::hash<Layouter::LineCacheQuery>;
  struct LineCacheHash;
 
  struct LineCacheEqualTo {
    using is_transparent = void;
 
    template <typename Tlhs, typename Trhs>
    bool operator()(const Tlhs &lhs, const Trhs &rhs) const
    {
      return lhs.state_before == rhs.state_before && lhs.str == rhs.str;
    }
  };
  struct LineCacheEqualTo {…};
 
public:
  struct LineCacheItem {
    /* Due to the type of data in the buffer differing depending on the Layouter, we need to pass our own deleter routine. */
    using Buffer = std::unique_ptr<void, void(*)(void *)>;
    /* Stuff that cannot be freed until the ParagraphLayout is freed */
    Buffer buffer{nullptr, [](void *){}}; 
    FontMap runs;              
 
    FontState state_after;     
    std::unique_ptr<ParagraphLayouter> layout = nullptr; 
 
    std::vector<std::unique_ptr<const ParagraphLayouter::Line>> cached_layout{}; 
    int cached_width = 0; 
  };
  struct LineCacheItem {…};
private:
  using LineCache = LRUCache<LineCacheKey, LineCacheItem, LineCacheHash, LineCacheEqualTo>;
  static std::unique_ptr<LineCache> linecache;
 
  static LineCacheItem &GetCachedParagraphLayout(std::string_view str, const FontState &state);
 
  using FontColourMap = std::map<TextColour, std::unique_ptr<Font>>;
  static FontColourMap fonts[FS_END];
public:
  static Font *GetFont(FontSize size, TextColour colour);
 
  Layouter(std::string_view str, int maxw = INT32_MAX, FontSize fontsize = FS_NORMAL);
  Dimension GetBounds();
  ParagraphLayouter::Position GetCharPosition(std::string_view::const_iterator ch) const;
  ptrdiff_t GetCharAtPosition(int x, size_t line_index) const;
 
  static void Initialize();
  static void ResetFontCache(FontSize size);
  static void ResetLineCache();
};
class Layouter : public std::vector<const ParagraphLayouter::Line *> {…};
 
ParagraphLayouter::Position GetCharPosInString(std::string_view str, size_t pos, FontSize start_fontsize = FS_NORMAL);
ptrdiff_t GetCharAtPosition(std::string_view str, int x, FontSize start_fontsize = FS_NORMAL);
 
template <> struct std::hash<Layouter::LineCacheQuery> {
  std::size_t operator()(const Layouter::LineCacheQuery &state) const noexcept
  {
    size_t h1 = std::hash<std::string_view>{}(state.str);
    size_t h2 = std::hash<FontState>{}(state.state_before);
    return h1 ^ (h2 << 1);
  }
};
template <> struct std::hash<Layouter::LineCacheQuery> {…};
 
struct Layouter::LineCacheHash {
  using is_transparent = void;
 
  std::size_t operator()(const Layouter::LineCacheKey &query) const { return std::hash<Layouter::LineCacheQuery>{}(LineCacheQuery{query.state_before, query.str}); }
  std::size_t operator()(const Layouter::LineCacheQuery &query) const { return std::hash<Layouter::LineCacheQuery>{}(query); }
};
struct Layouter::LineCacheHash {…};
 
#endif /* GFX_LAYOUT_H */