attributearray.cc

Go to the documentation of this file.

#include "ion/gfx/attributearray.h"

#include "ion/base/invalid.h"
#include "ion/base/logging.h"
#include "ion/gfx/shaderinputregistry.h"

namespace ion {
namespace gfx {

AttributeArray::AttributeArray()
    : attribute_indices_(*this),
      buffer_attributes_(kAttributeChanged, kAttributeSlotCount, this),
      simple_attributes_(*this),
      enables_(kAttributeEnabledChanged, kAttributeSlotCount, this) {
}

AttributeArray::~AttributeArray() {
  const size_t num_attributes = buffer_attributes_.GetCount();
  for (size_t i = 0; i < num_attributes; ++i) {
    const Attribute& a = buffer_attributes_.Get(i);
    BufferObject* bo =
        a.GetValue<BufferObjectElement>().buffer_object.Get();
    if (bo) bo->RemoveReceiver(this);
  }
}

size_t AttributeArray::GetAttributeIndexByName(const std::string& name) {
  size_t index = base::kInvalidIndex;
  const size_t num_attributes = attribute_indices_.size();
  for (size_t i = 0; i < num_attributes; ++i) {
    const Index& attr_index = attribute_indices_[i];
    const size_t idx = attr_index.index;
    const Attribute& a = attribute_indices_[i].type == Index::kBuffer
                             ? buffer_attributes_.Get(idx)
                             : simple_attributes_[idx];
    if (const ShaderInputRegistry::AttributeSpec* spec =
            ShaderInputRegistry::GetSpec(a)) {
      if (spec->name == name) {
        index = i;
        break;
      }
    }
  }
  return index;
}

size_t AttributeArray::AddAttribute(const Attribute& attribute) {
  if (!attribute.IsValid())
    return base::kInvalidIndex;

  const size_t num_attributes = attribute_indices_.size();
  const size_t registry_id = attribute.GetRegistry().GetId();
  const size_t index = attribute.GetIndexInRegistry();
  for (size_t i = 0; i < num_attributes; ++i) {
    const Index& attr_index = attribute_indices_[i];
    const size_t idx = attr_index.index;
    const Attribute& a = attribute_indices_[i].type == Index::kBuffer ?
        buffer_attributes_.Get(idx) : simple_attributes_[idx];
    if (a.GetRegistry().GetId() == registry_id &&
        a.GetIndexInRegistry() == index) {
      return i;
    }
  }
  if (attribute.GetType() == kBufferObjectElementAttribute) {
    Index new_index(Index::kBuffer, buffer_attributes_.GetCount());
    attribute_indices_.push_back(new_index);
    buffer_attributes_.Add(attribute);
    if (BufferObject* bo =
            attribute.GetValue<BufferObjectElement>().buffer_object.Get())
      bo->AddReceiver(this);
    enables_.Add(true);
  } else {
    Index new_index(Index::kSimple, simple_attributes_.size());
    attribute_indices_.push_back(new_index);
    simple_attributes_.push_back(attribute);
  }
  return num_attributes;
}

bool AttributeArray::ReplaceAttribute(size_t index,
                                      const Attribute& attribute) {
  if (!attribute.IsValid())
    return false;

  const size_t num_attributes = attribute_indices_.size();
  if (index >= num_attributes) {
    return false;
  } else {
    Index& attr_index = attribute_indices_[index];
    if (attr_index.type == Index::kBuffer) {
      if (attribute.GetType() == kBufferObjectElementAttribute) {
        if (BufferObject* new_bo =
                attribute.GetValue<BufferObjectElement>().buffer_object.Get())
          new_bo->AddReceiver(this);
        return buffer_attributes_.Set(attr_index.index, attribute);
      } else {
        RemoveAttribute(attr_index);

        attr_index.index = simple_attributes_.size();
        attr_index.type = Index::kSimple;
        simple_attributes_.push_back(attribute);
        return true;
      }
    } else {
      if (attribute.GetType() == kBufferObjectElementAttribute) {
        if (BufferObject* new_bo =
                attribute.GetValue<BufferObjectElement>().buffer_object.Get())
          new_bo->AddReceiver(this);

        RemoveAttribute(attr_index);

        attr_index.index = buffer_attributes_.GetCount();
        attr_index.type = Index::kBuffer;
        buffer_attributes_.Add(attribute);
        enables_.Add(true);
        return true;
      } else {
        if (simple_attributes_[attr_index.index] == attribute) {
          return false;
        } else {
          simple_attributes_[attr_index.index] = attribute;
          return true;
        }
      }
    }
  }
}

void AttributeArray::EnableAttribute(const size_t attribute_index,
                                     bool enabled) {
  if (attribute_index < attribute_indices_.size()) {
    const Index& attr_index = attribute_indices_[attribute_index];
    if (attr_index.type == Index::kBuffer)
      enables_.Set(attr_index.index, enabled);
  }
}

bool AttributeArray::IsAttributeEnabled(const size_t attribute_index) const {
  DCHECK_EQ(buffer_attributes_.GetCount(), enables_.GetCount());
  if (attribute_index < attribute_indices_.size()) {
    const Index& attr_index = attribute_indices_[attribute_index];
    return attr_index.type == Index::kSimple ||
        (enables_.Get(attr_index.index) &&
         buffer_attributes_.Get(attr_index.index).IsValid());
  } else {
    return false;
  }
}

const Attribute& AttributeArray::GetAttribute(
    const size_t attribute_index) const {
  if (attribute_index < attribute_indices_.size()) {
    const Index& attr_index = attribute_indices_[attribute_index];
    if (attr_index.type == Index::kBuffer)
      return buffer_attributes_.Get(attr_index.index);
    else
      return simple_attributes_[attr_index.index];
  } else {
    return base::InvalidReference<Attribute>();
  }
}

Attribute* AttributeArray::GetMutableAttribute(const size_t attribute_index) {
  if (attribute_index < attribute_indices_.size()) {
    const Index& attr_index = attribute_indices_[attribute_index];
    if (attr_index.type == Index::kBuffer)
      return GetMutableBufferAttribute(attr_index.index);
    else
      return GetMutableSimpleAttribute(attr_index.index);
  } else {
    return NULL;
  }
}

AttributeArray::Index* AttributeArray::FindIndexOfAttribute(
    AttributeArray::Index::Type type, size_t index) {
  const Index target(type, index);
  base::AllocVector<Index>::iterator it =
      std::find(attribute_indices_.begin(), attribute_indices_.end(), target);
  return it == attribute_indices_.end() ? NULL : &(*it);
}

void AttributeArray::RemoveAttribute(const Index& attr_index) {
  if (attr_index.type == Index::kBuffer) {
    DCHECK(buffer_attributes_.GetCount());

    Index* old_index = FindIndexOfAttribute(
        Index::kBuffer, buffer_attributes_.GetCount() - 1U);
    DCHECK(old_index);
    old_index->index = attr_index.index;

    if (BufferObject* old_bo = buffer_attributes_.Get(attr_index.index)
                                   .GetValue<BufferObjectElement>()
                                   .buffer_object.Get()) {
      bool perform_remove = true;
      const size_t num_attributes = buffer_attributes_.GetCount();
      for (size_t i = 0; i < num_attributes; ++i) {
        if (i != attr_index.index) {
          const Attribute& a = buffer_attributes_.Get(i);
          BufferObject* bo =
              a.GetValue<BufferObjectElement>().buffer_object.Get();
          if (bo == old_bo) {
            perform_remove = false;
            break;
          }
        }
      }
      if (perform_remove) old_bo->RemoveReceiver(this);
    }
    buffer_attributes_.Remove(attr_index.index);
    enables_.Remove(attr_index.index);
  } else {
    DCHECK(simple_attributes_.size());

    Index* old_index = FindIndexOfAttribute(
        Index::kSimple, simple_attributes_.size() - 1U);
    DCHECK(old_index);
    old_index->index = attr_index.index;

    simple_attributes_[attr_index.index] = simple_attributes_.back();
    simple_attributes_.resize(simple_attributes_.size() - 1U);
  }
}

void AttributeArray::OnNotify(const base::Notifier* notifier) {
  if (GetResourceCount()) {
    const size_t num_attributes = buffer_attributes_.GetCount();
    for (size_t i = 0; i < num_attributes; ++i) {
      const Attribute& a = buffer_attributes_.Get(i);
      DCHECK(a.IsValid());
      BufferObject* bo =
          a.GetValue<BufferObjectElement>().buffer_object.Get();
      if (bo == notifier)
        OnChanged(static_cast<Changes>(kAttributeChanged + i));
    }
  }
}

}  // namespace gfx
}  // namespace ion