layout.h

Go to the documentation of this file.

#ifndef ION_TEXT_LAYOUT_H_
#define ION_TEXT_LAYOUT_H_


#include <vector>

#ifdef ION_PLATFORM_NACL
#include <sys/types.h>
#undef quad
#endif

#include "ion/base/invalid.h"
#include "ion/base/stlalloc/allocset.h"
#include "ion/math/range.h"
#include "ion/math/vector.h"

namespace ion {
namespace text {

typedef uint64 GlyphIndex;
typedef base::AllocSet<GlyphIndex> GlyphSet;



enum HorizontalAlignment {
  kAlignLeft,     // Put the left edge of the text at the point.
  kAlignHCenter,  // Put the horizontal center of the text at the point.
  kAlignRight,    // Put the right edge of the text at the point.
};

enum VerticalAlignment {
  kAlignTop,       // Put the top edge of the text at the point.
  kAlignVCenter,   // Put the vertical center of the text at the point.
  kAlignBaseline,  // Put the text baseline at the point.
  kAlignBottom,    // Put the bottom edge of the text at the point.
};


struct LayoutOptions {
  LayoutOptions()
      : target_point(0.0f, 0.0f),
        target_size(0.0f, 1.0f),
        horizontal_alignment(kAlignLeft),
        vertical_alignment(kAlignBaseline),
        line_spacing(1.0f) {}

  math::Point2f target_point;
  math::Vector2f target_size;
  HorizontalAlignment horizontal_alignment;
  VerticalAlignment vertical_alignment;
  float line_spacing;
};


class ION_API Layout {
 public:
  struct Quad {
    Quad() {
      points[0] = points[1] = points[2] = points[3] = math::Point3f::Zero();
    }

    Quad(const math::Point3f& lower_left, const math::Point3f& lower_right,
         const math::Point3f& upper_right, const math::Point3f& upper_left) {
      points[0] = lower_left;
      points[1] = lower_right;
      points[2] = upper_right;
      points[3] = upper_left;
    }

    explicit Quad(const math::Point3f points_in[4]) {
      for (int i = 0; i < 4; ++i)
        points[i] = points_in[i];
    }

    math::Point3f points[4];  // Quadrilateral points.
  };

  struct Glyph {
    Glyph() : glyph_index(0) {}

    Glyph(GlyphIndex glyph_index_in,
          const Quad& quad_in,
          const math::Range2f& bounds_in,
          const math::Vector2f& offset_in)
      : glyph_index(glyph_index_in), quad(quad_in),
        bounds(bounds_in), offset(offset_in) {}

    GlyphIndex glyph_index;  // Index of the glyph in the font.
    Quad quad;               // Quadrilateral points to use for rendering.
    math::Range2f bounds;    // Tight bounds of the glyph.
    math::Vector2f offset;
  };

  Layout() : line_advance_height_(0.f) {}
  ~Layout() {}

  bool AddGlyph(const Glyph& glyph);

  size_t GetGlyphCount() const;

  void Reserve(size_t s);

  const Glyph& GetGlyph(size_t i) const;

  bool ReplaceGlyph(size_t i, const Glyph& new_glyph);

  void GetGlyphSet(GlyphSet* glyphs) const;

  float GetLineAdvanceHeight() const;
  void SetLineAdvanceHeight(float line_advance);

 private:
  std::vector<Glyph> glyphs_;
  float line_advance_height_;
};

std::ostream& operator<<(std::ostream& os, const Layout& layout);
std::ostream& operator<<(std::ostream& out, const Layout::Glyph& g);
std::ostream& operator<<(std::ostream& out, const Layout::Quad& q);

}  // namespace text
}  // namespace ion

#endif  // ION_TEXT_LAYOUT_H_