builder.h

Go to the documentation of this file.

#ifndef ION_TEXT_BUILDER_H_
#define ION_TEXT_BUILDER_H_

#include <string>

#include "ion/base/referent.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/gfx/attributearray.h"
#include "ion/gfx/bufferobject.h"
#include "ion/gfx/node.h"
#include "ion/gfx/sampler.h"
#include "ion/gfx/shaderinputregistry.h"
#include "ion/gfxutils/shadermanager.h"
#include "ion/math/vector.h"
#include "ion/text/font.h"
#include "ion/text/fontimage.h"

namespace ion {
namespace gfx {
class Shape;
}

namespace text {
class Layout;

class ION_API Builder : public base::Referent {
 public:
  const FontImagePtr& GetFontImage() const { return font_image_; }

  void SetFontImage(const FontImagePtr& font_image) {
    font_image_ = font_image;
  }

  const FontPtr GetFont() const {
    return font_image_.Get() ? font_image_->GetFont() : FontPtr();
  }

  bool Build(const Layout& layout, gfx::BufferObject::UsageMode usage_mode);

  const gfx::NodePtr& GetNode() const { return node_; }

  math::Range3f GetExtents() const { return text_extents_; }

 protected:
  Builder(const FontImagePtr& font_image,
          const gfxutils::ShaderManagerPtr& shader_manager,
          const base::AllocatorPtr& allocator);

  ~Builder() override;

  const base::AllocatorPtr& GetAllocator() { return allocator_; }



  virtual const gfx::ShaderInputRegistryPtr GetShaderInputRegistry() = 0;

  virtual void GetShaderStrings(std::string* id_string,
                                std::string* vertex_source,
                                std::string* fragment_source) = 0;

  virtual void UpdateUniforms(const gfx::ShaderInputRegistryPtr& registry,
                              gfx::Node* node) = 0;

  virtual void BindAttributes(const gfx::AttributeArrayPtr& attr_array,
                              const gfx::BufferObjectPtr& buffer_object) = 0;

  virtual base::AllocVector<char> BuildVertexData(const Layout& layout,
                                                  size_t* vertex_size,
                                                  size_t* num_vertices) = 0;



  const FontImage::ImageData* GetImageData() const { return image_data_; }

  const gfx::TexturePtr GetFontImageTexture();

  bool UpdateFontImageTextureUniform(size_t index, gfx::Node* node);

  void StoreGlyphVertices(const Layout& layout, size_t glyph_index,
                          math::Point3f positions[4],
                          math::Point2f texture_coords[4]);

 private:
  const gfx::ShaderProgramPtr BuildShaderProgram();

  bool UpdateAttributeArray(
      const Layout& layout, gfx::BufferObject::UsageMode usage_mode,
      const gfx::AttributeArrayPtr& attr_array);

  void UpdateShape(const Layout& layout,
                   gfx::BufferObject::UsageMode usage_mode, gfx::Shape* shape);

  FontImagePtr font_image_;
  gfxutils::ShaderManagerPtr shader_manager_;
  base::AllocatorPtr allocator_;
  gfx::NodePtr node_;
  gfx::ShaderInputRegistryPtr registry_;
  gfx::SamplerPtr sampler_;
  math::Range3f text_extents_;
  const FontImage::ImageData* image_data_;
};

typedef base::ReferentPtr<Builder>::Type BuilderPtr;

}  // namespace text
}  // namespace ion

#endif  // ION_TEXT_BUILDER_H_