builder.cc

Go to the documentation of this file.

#include "ion/text/builder.h"

#include "ion/base/allocationmanager.h"
#include "ion/base/datacontainer.h"
#include "ion/base/invalid.h"
#include "ion/base/logging.h"
#include "ion/gfx/indexbuffer.h"
#include "ion/gfx/statetable.h"
#include "ion/gfx/texture.h"
#include "ion/gfxutils/shadersourcecomposer.h"
#include "ion/math/range.h"
#include "ion/text/layout.h"

namespace ion {
namespace text {




namespace {

static const GlyphSet GetGlyphSetFromLayout(
    const Layout& layout, const base::AllocatorPtr& allocator) {
  GlyphSet glyph_set(allocator);
  const size_t num_glyphs = layout.GetGlyphCount();
  for (size_t i = 0; i < num_glyphs; ++i)
    glyph_set.insert(layout.GetGlyph(i).glyph_index);
  return glyph_set;
}

static const gfx::StateTablePtr BuildStateTable(
    const base::AllocatorPtr& allocator) {
  gfx::StateTablePtr state_table(new(allocator) gfx::StateTable());
  state_table->Enable(gfx::StateTable::kCullFace, false);
  state_table->Enable(gfx::StateTable::kBlend, true);
  state_table->SetBlendEquations(gfx::StateTable::kAdd,
                                 gfx::StateTable::kAdd);
  state_table->SetBlendFunctions(gfx::StateTable::kOne,
                                 gfx::StateTable::kOneMinusSrcAlpha,
                                 gfx::StateTable::kOne,
                                 gfx::StateTable::kOneMinusSrcAlpha);
  return state_table;
}

static const gfx::IndexBufferPtr BuildIndexBuffer(
    const Layout& layout, gfx::BufferObject::UsageMode usage_mode,
    const base::AllocatorPtr& allocator) {
  const base::AllocatorPtr& al =
      base::AllocationManager::GetNonNullAllocator(allocator);

  const size_t num_glyphs = layout.GetGlyphCount();
  base::AllocVector<uint16> indices(
      al->GetAllocatorForLifetime(base::kShortTerm));
  indices.reserve(6 * num_glyphs);  // 2 triangles per glyph.

  for (size_t i = 0; i < num_glyphs; ++i) {
    indices.push_back(static_cast<uint16>(4 * i + 0));
    indices.push_back(static_cast<uint16>(4 * i + 1));
    indices.push_back(static_cast<uint16>(4 * i + 2));
    indices.push_back(static_cast<uint16>(4 * i + 0));
    indices.push_back(static_cast<uint16>(4 * i + 2));
    indices.push_back(static_cast<uint16>(4 * i + 3));
  }

  gfx::IndexBufferPtr index_buffer(new(al) gfx::IndexBuffer);
  base::DataContainerPtr container =
      base::DataContainer::CreateAndCopy<uint16>(
          &indices[0], indices.size(),
          usage_mode == gfx::BufferObject::kStaticDraw, al);
  index_buffer->AddSpec(gfx::BufferObject::kUnsignedShort, 1, 0);
  index_buffer->SetData(container, sizeof(indices[0]), indices.size(),
                        usage_mode);
  return index_buffer;
}

static const gfx::BufferObjectPtr GetBufferObject(
    const gfx::AttributeArray& attr_array) {
  gfx::BufferObjectPtr bo;
  if (attr_array.GetBufferAttributeCount() >= 1U) {
    const gfx::Attribute& attr = attr_array.GetBufferAttribute(0);
    DCHECK_EQ(attr.GetType(), gfx::kBufferObjectElementAttribute);
    bo = attr.GetValue<gfx::BufferObjectElement>().buffer_object;
  }
  return bo;
}

static bool CanBufferObjectBeReused(const gfx::BufferObject& bo,
                                    size_t num_vertices) {
  return (bo.GetCount() == num_vertices &&
          bo.GetData().Get() &&
          bo.GetUsageMode() != gfx::BufferObject::kStaticDraw &&
          bo.GetData().Get() &&
          bo.GetData()->GetData());
}


}  // anonymous namespace




Builder::Builder(const FontImagePtr& font_image,
                 const gfxutils::ShaderManagerPtr& shader_manager,
                 const base::AllocatorPtr& allocator)
    : font_image_(font_image),
      shader_manager_(shader_manager),
      allocator_(base::AllocationManager::GetNonNullAllocator(allocator)),
      image_data_(NULL) {}

Builder::~Builder() {}

bool Builder::Build(const Layout& layout,
                    gfx::BufferObject::UsageMode usage_mode) {
  if (!font_image_.Get() || !layout.GetGlyphCount())
    return false;

  DCHECK(!image_data_);
  const GlyphSet glyph_set = GetGlyphSetFromLayout(
      layout, allocator_->GetAllocatorForLifetime(base::kShortTerm));
  const FontImage::ImageData& image_data =
      font_image_->FindImageData(glyph_set);
  if (base::IsInvalidReference(image_data))
    return false;
  image_data_ = &image_data;

  if (!node_.Get())
    node_.Reset(new (allocator_) gfx::Node);

  if (!node_->GetShaderProgram().Get())
    node_->SetShaderProgram(BuildShaderProgram());
  if (!node_->GetStateTable().Get())
    node_->SetStateTable(BuildStateTable(allocator_));

  DCHECK(registry_.Get());
  UpdateUniforms(registry_, node_.Get());

  if (node_->GetShapes().empty())
    node_->AddShape(gfx::ShapePtr(new (allocator_) gfx::Shape()));
  UpdateShape(layout, usage_mode, node_->GetShapes()[0].Get());

  image_data_ = NULL;
  return true;
}

const gfx::ShaderProgramPtr Builder::BuildShaderProgram() {
  if (!registry_.Get())
    registry_ = GetShaderInputRegistry();
  std::string id_string;
  std::string vertex_source;
  std::string fragment_source;
  GetShaderStrings(&id_string, &vertex_source, &fragment_source);

  gfx::ShaderProgramPtr program;
  if (shader_manager_.Get()) {
    program = shader_manager_->CreateShaderProgram(
        id_string, registry_,
        gfxutils::ShaderSourceComposerPtr(
            new(allocator_) gfxutils::StringComposer(
                id_string + " vertex shader", vertex_source)),
        gfxutils::ShaderSourceComposerPtr(
            new(allocator_) ion::gfxutils::StringComposer(
                id_string + " fragment shader", fragment_source)));
  } else {
    program = new(allocator_) gfx::ShaderProgram(registry_);
    program->SetLabel(id_string);
    program->SetVertexShader(
        gfx::ShaderPtr(new(allocator_) gfx::Shader(vertex_source)));
    program->SetFragmentShader(
        gfx::ShaderPtr(new(allocator_) gfx::Shader(fragment_source)));
  }
  return program;
}

const gfx::TexturePtr Builder::GetFontImageTexture() {
  gfx::TexturePtr texture;
  if (font_image_.Get()) {
    DCHECK(image_data_);
    texture = image_data_->texture;
  }
  return texture;
}

bool Builder::UpdateFontImageTextureUniform(size_t index, gfx::Node* node) {
  bool ok = false;
  if (node && index < node->GetUniforms().size()) {
    const gfx::Uniform& uniform = node->GetUniforms()[index];
    if (uniform.IsValid() && uniform.GetType() == gfx::kTextureUniform) {
      gfx::TexturePtr texture = GetFontImageTexture();
      if (uniform.GetValue<gfx::TexturePtr>() != texture)
        node->SetUniformValue<gfx::TexturePtr>(index, texture);
      ok = true;
    }
  }
  return ok;
}

void Builder::StoreGlyphVertices(const Layout& layout, size_t glyph_index,
                                 math::Point3f positions[4],
                                 math::Point2f texture_coords[4]) {
  const Layout::Glyph& glyph = layout.GetGlyph(glyph_index);
  DCHECK(!base::IsInvalidReference(glyph));

  math::Range2f texcoord_rect;
  DCHECK(image_data_);
  if (FontImage::GetTextureCoords(*image_data_, glyph.glyph_index,
                                  &texcoord_rect)) {
    for (int i = 0; i < 4; ++i) {
      positions[i] = glyph.quad.points[i];
      text_extents_.ExtendByPoint(positions[i]);
    }

    const float u_min = texcoord_rect.GetMinPoint()[0];
    const float u_max = texcoord_rect.GetMaxPoint()[0];
    const float v_min = texcoord_rect.GetMaxPoint()[1];
    const float v_max = texcoord_rect.GetMinPoint()[1];
    texture_coords[0].Set(u_min, v_min);
    texture_coords[1].Set(u_max, v_min);
    texture_coords[2].Set(u_max, v_max);
    texture_coords[3].Set(u_min, v_max);
  } else {
    for (int i = 0; i < 4; ++i) {
      positions[i] = math::Point3f::Zero();
      texture_coords[i] = math::Point2f::Zero();
    }
  }
}

bool Builder::UpdateAttributeArray(
    const Layout& layout, gfx::BufferObject::UsageMode usage_mode,
    const gfx::AttributeArrayPtr& attr_array) {
  DCHECK(attr_array.Get());
  const base::AllocatorPtr& allocator = GetAllocator();

  size_t vertex_size = 0U;
  size_t num_vertices = 0U;
  text_extents_.MakeEmpty();
  base::AllocVector<char> vertex_data =
      BuildVertexData(layout, &vertex_size, &num_vertices);
  DCHECK_LT(0U, vertex_size);
  DCHECK_LT(0U, num_vertices);

  gfx::BufferObjectPtr bo = GetBufferObject(*attr_array);
  bool reuse_buffer = false;
  if (!bo.Get()) {
    bo = new (allocator) gfx::BufferObject;
  } else {
    reuse_buffer = CanBufferObjectBeReused(*bo, num_vertices);
  }

  if (reuse_buffer) {
    base::DataContainer& container = *bo->GetData();
    char* old_vertex_data = container.GetMutableData<char>();
    DCHECK(old_vertex_data);
    memcpy(old_vertex_data, &vertex_data[0], vertex_size * num_vertices);
  } else {
    base::DataContainerPtr container =
        base::DataContainer::CreateAndCopy<char>(
            &vertex_data[0], vertex_size * num_vertices,
            usage_mode == gfx::BufferObject::kStaticDraw, GetAllocator());
    bo->SetData(container, vertex_size, num_vertices, usage_mode);

    if (!attr_array->GetBufferAttributeCount()) {
      BindAttributes(attr_array, bo);
    }
  }
  return reuse_buffer;
}

void Builder::UpdateShape(
    const Layout& layout, gfx::BufferObject::UsageMode usage_mode,
    gfx::Shape* shape) {
  shape->SetPrimitiveType(gfx::Shape::kTriangles);

  if (!shape->GetAttributeArray().Get())
    shape->SetAttributeArray(
        gfx::AttributeArrayPtr(new (allocator_) gfx::AttributeArray));

  const bool buffer_reused =
      UpdateAttributeArray(layout, usage_mode, shape->GetAttributeArray());
  if (!shape->GetIndexBuffer().Get() || !buffer_reused) {
    shape->SetIndexBuffer(BuildIndexBuffer(
        layout, gfx::BufferObject::kStaticDraw, allocator_));
  }
}

}  // namespace text
}  // namespace ion