attributearray.h

Go to the documentation of this file.

#ifndef ION_GFX_ATTRIBUTEARRAY_H_
#define ION_GFX_ATTRIBUTEARRAY_H_

#include "ion/base/referent.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/gfx/attribute.h"
#include "ion/gfx/resourceholder.h"

namespace ion {
namespace gfx {

static const size_t kAttributeSlotCount = 32;

class ION_API AttributeArray : public ResourceHolder {
 public:
  enum Changes {
    kAttributeChanged = kNumBaseChanges,
    kAttributeEnabledChanged = kAttributeChanged + kAttributeSlotCount,
    kNumChanges = kAttributeEnabledChanged + kAttributeSlotCount
  };

  AttributeArray();

  size_t GetAttributeIndexByName(const std::string& name);

  size_t AddAttribute(const Attribute& attribute);
  bool ReplaceAttribute(size_t index, const Attribute& attribute);

  void EnableAttribute(const size_t attribute_index, bool enabled);
  bool IsAttributeEnabled(const size_t attribute_index) const;
  void EnableBufferAttribute(const size_t i, bool enabled) {
    enables_.Set(i, enabled);
  }
  bool IsBufferAttributeEnabled(const size_t i) const {
    const bool& value = enables_.Get(i);
    return base::IsInvalidReference(value) ? false : value;
  }

  size_t GetAttributeCount() const {
    return attribute_indices_.size();
  }
  size_t GetBufferAttributeCount() const {
    return buffer_attributes_.GetCount();
  }
  size_t GetSimpleAttributeCount() const {
    return simple_attributes_.size();
  }

  const Attribute& GetAttribute(const size_t attribute_index) const;
  const Attribute& GetBufferAttribute(const size_t i) const {
    return buffer_attributes_.Get(i);
  }
  const Attribute& GetSimpleAttribute(const size_t i) const {
    if (i < simple_attributes_.size()) {
      return simple_attributes_[i];
    } else {
      return base::InvalidReference<Attribute>();
    }
  }

  Attribute* GetMutableAttribute(const size_t attribute_index);
  Attribute* GetMutableBufferAttribute(const size_t i) {
    return buffer_attributes_.GetMutable(i);
  }
  Attribute* GetMutableSimpleAttribute(const size_t i) {
    if (i < simple_attributes_.size()) {
      return &simple_attributes_[i];
    } else {
      return NULL;
    }
  }

 protected:
  ~AttributeArray() override;

 private:
  struct Index {
    enum Type {
      kBuffer,
      kSimple
    };
    Index(Type type_in, size_t index_in) : type(type_in), index(index_in) {}

    bool operator==(const Index& other) const {
      return type == other.type && index == other.index;
    }
    Type type;
    size_t index;
  };

  Index* FindIndexOfAttribute(Index::Type type, size_t index);

  void RemoveAttribute(const Index& attr_index);

  void OnNotify(const base::Notifier* notifier) override;

  base::AllocVector<Index> attribute_indices_;

  VectorField<Attribute> buffer_attributes_;

  base::AllocVector<Attribute> simple_attributes_;

  VectorField<bool> enables_;
};

typedef base::ReferentPtr<AttributeArray>::Type AttributeArrayPtr;

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_ATTRIBUTEARRAY_H_