buffertoattributebinder.h

Go to the documentation of this file.

#ifndef ION_GFXUTILS_BUFFERTOATTRIBUTEBINDER_H_
#define ION_GFXUTILS_BUFFERTOATTRIBUTEBINDER_H_

#include <string>

#include "base/integral_types.h"
#include "ion/base/invalid.h"
#include "ion/base/logging.h"
#include "ion/base/static_assert.h"
#include "ion/base/type_structs.h"
#include "ion/base/varianttyperesolver.h"
#include "ion/gfx/attribute.h"
#include "ion/gfx/attributearray.h"
#include "ion/gfx/bufferobject.h"
#include "ion/gfx/shaderinputregistry.h"

namespace ion {
namespace gfxutils {

template <typename T> ION_API
gfx::BufferObject::ComponentType GetComponentType();
template <typename T> ION_API size_t GetComponentCount();


template <typename T>
class BufferToAttributeBinder {
 public:
  explicit BufferToAttributeBinder(const T& base_struct)
      : base_address_(reinterpret_cast<const char*>(&base_struct)) {
    DCHECK(base_address_);
  }

  ~BufferToAttributeBinder() {}

  void Apply(const gfx::ShaderInputRegistryPtr& reg,
             const gfx::AttributeArrayPtr& aa,
             const gfx::BufferObjectPtr& bo) {
    const size_t num_bindings = bindings_.size();
    for (size_t i = 0; i < num_bindings; ++i) {
      const size_t element_index = bo->AddSpec(
          bindings_[i].type, bindings_[i].count, bindings_[i].offset);
      gfx::Attribute a = reg->Create<gfx::Attribute>(
          bindings_[i].name, gfx::BufferObjectElement(bo, element_index));
      DCHECK(a.IsValid());
      a.SetFixedPointNormalized(bindings_[i].normalize);
      a.SetDivisor(bindings_[i].divisor);
      aa->AddAttribute(a);
    }
  }

  bool AreBindingsPacked(const gfx::ShaderInputRegistry& reg) {
    size_t struct_size = 0;
    bool struct_is_packed = true;
    const size_t num_bindings = bindings_.size();
    for (size_t i = 0; i < num_bindings; ++i) {
      if (reg.Contains(bindings_[i].name)) {
        struct_size += bindings_[i].size;
        if (bindings_[i].offset) {
          size_t closest = i;
          if (!IsBindingPacked(i, &closest)) {
            LOG(WARNING)
                << "Attribute '" << bindings_[i].name << "' is not"
                << " tightly packed, performance may suffer.  The closest"
                << " binding before it is '" << bindings_[closest].name
                << ",' but it ends at offset "
                << (bindings_[closest].offset + bindings_[closest].size)
                << ", while '" << bindings_[i].name << "' starts at offset "
                << bindings_[i].offset;
            struct_is_packed = false;
          }
        }
      }
    }
    if (struct_size != sizeof(T)) {
      LOG(WARNING) << "Vertex struct is not tightly packed ("
                   << (sizeof(T) - struct_size)
                   << " byte(s) are wasted), performance may suffer.";
      struct_is_packed = false;
    }
    return struct_is_packed;
  }

  template <typename FieldType>
  BufferToAttributeBinder& Bind(const FieldType& field,
                                const std::string& attribute_name) {
    return BindInternal(field, attribute_name, false, 0);
  }

  template <typename FieldType>
  BufferToAttributeBinder& BindAndNormalize(const FieldType& field,
                                            const std::string& attribute_name) {
    return BindInternal(field, attribute_name, true, 0);
  }

  template <typename FieldType>
  BufferToAttributeBinder& Bind(const FieldType& field,
                                const std::string& attribute_name,
                                unsigned int divisor) {
    return BindInternal(field, attribute_name, false, divisor);
  }

  template <typename FieldType>
  BufferToAttributeBinder& BindAndNormalize(const FieldType& field,
                                            const std::string& attribute_name,
                                            unsigned int divisor) {
    return BindInternal(field, attribute_name, true, divisor);
  }

 private:
  typedef base::Variant<int8, uint8, int16, uint16, int32, uint32,
                        float,
                        math::VectorBase1i8, math::VectorBase1ui8,
                        math::VectorBase1i16, math::VectorBase1ui16,
                        math::VectorBase1i, math::VectorBase1ui,
                        math::VectorBase1f,
                        math::VectorBase2i8, math::VectorBase2ui8,
                        math::VectorBase2i16, math::VectorBase2ui16,
                        math::VectorBase2i, math::VectorBase2ui,
                        math::VectorBase2f,
                        math::VectorBase3i8, math::VectorBase3ui8,
                        math::VectorBase3i16, math::VectorBase3ui16,
                        math::VectorBase3i, math::VectorBase3ui,
                        math::VectorBase3f,
                        math::VectorBase4i8, math::VectorBase4ui8,
                        math::VectorBase4i16, math::VectorBase4ui16,
                        math::VectorBase4i, math::VectorBase4ui,
                        math::VectorBase4f, math::Matrix2f, math::Matrix3f,
                        math::Matrix4f> AttributeType;

  struct Binding {
    Binding(size_t offset_in, size_t count_in, size_t size_in,
            const std::string& name_in,
            gfx::BufferObject::ComponentType type_in, bool normalize_in,
            unsigned int divisor_in)
        : offset(offset_in),
          count(count_in),
          size(size_in),
          name(name_in),
          type(type_in),
          normalize(normalize_in),
          divisor(divisor_in) {}
    size_t offset;
    size_t count;
    size_t size;
    std::string name;
    gfx::BufferObject::ComponentType type;
    bool normalize;
    unsigned int divisor;
  };

  BufferToAttributeBinder()
      :  base_address_(NULL) {}

  template <typename FieldType>
  BufferToAttributeBinder& BindInternal(const FieldType& field,
                                        const std::string& attribute_name,
                                        bool normalize, unsigned int divisor) {
    typedef typename base::VariantTypeResolver<
      AttributeType, FieldType>::Type ResolvedFieldType;
    ION_STATIC_ASSERT((!base::IsSameType<void, ResolvedFieldType>::value),
                      "Cannot resolve attribute type to bind");
    const char* field_address = reinterpret_cast<const char*>(&field);
    const ssize_t offset = field_address - base_address_;
    bindings_.push_back(Binding(offset, GetComponentCount<ResolvedFieldType>(),
                                sizeof(FieldType), attribute_name,
                                GetComponentType<ResolvedFieldType>(),
                                normalize, divisor));
    return *this;
  }

  bool IsBindingPacked(size_t i, size_t* closest) {
    bool packed = false;
    size_t closest_index = i;
    size_t closest_distance = 0;
    const size_t num_bindings = bindings_.size();
    for (size_t j = 0; j < num_bindings; ++j) {
      const size_t end_of_binding = bindings_[j].offset + bindings_[j].size;
      if (end_of_binding == bindings_[i].offset) {
        packed = true;
        break;
      } else if (end_of_binding < bindings_[i].offset &&
                 end_of_binding > closest_distance) {
        closest_index = j;
        closest_distance = end_of_binding;
      }
    }
    if (closest)
      *closest = closest_index;
    return packed;
  }

  const char* base_address_;
  std::vector<Binding> bindings_;
};

}  // namespace gfxutils
}  // namespace ion

#endif  // ION_GFXUTILS_BUFFERTOATTRIBUTEBINDER_H_