shaderinput.h

Go to the documentation of this file.

#ifndef ION_GFX_SHADERINPUT_H_
#define ION_GFX_SHADERINPUT_H_

#include <cstring>  // For size_t.

#include "base/integral_types.h"
#include "ion/base/allocator.h"

namespace ion {
namespace gfx {

class ShaderInputRegistry;

class ShaderInputBase {
 public:
  enum Tag {
    kUniform,
    kAttribute
  };

  ShaderInputBase() {}
  ~ShaderInputBase() {}

 protected:
  static uint64 GetNewStamp();
};

template <typename ValueHolderType, typename ValueEnumType>
class ShaderInput : public ShaderInputBase {
 public:
  typedef ValueHolderType HolderType;
  typedef ValueEnumType ValueType;

  ~ShaderInput() {}

  bool IsValid() const { return registry_ != NULL; }

  const ShaderInputRegistry& GetRegistry() const { return *registry_; }

  size_t GetIndexInRegistry() const { return index_in_registry_; }

  size_t GetRegistryId() const { return registry_id_; }

  size_t GetArrayIndex() const { return array_index_; }

  ValueType GetType() const { return type_; }

  template <typename T> const T& GetValue() const {
    return value_.template Get<T>();
  }

  template <typename T> const T& GetValueAt(size_t i) const {
    return value_.template GetValueAt<T>(i);
  }

  size_t GetCount() const {
    return value_.GetCount();
  }

  template <typename T> bool Is() const {
    return value_.template Is<T>();
  }

  template <typename T> bool IsArrayOf() const {
    return value_.template IsArrayOf<T>();
  }

  template <typename T> bool SetValue(const T& value) {
    if (value_.template IsAssignableTo<T>()) {
      SetNewStamp();
      value_.Set(value);
      return true;
    } else {
      return false;
    }
  }

  template <typename T> bool SetValueAt(size_t i, const T& value) {
    if (value_.template ElementsAssignableTo<T>()) {
      SetNewStamp();
      value_.SetValueAt(i, value);
      return true;
    } else {
      return false;
    }
  }

  uint64 GetStamp() const { return stamp_; }

 protected:
  ShaderInput()
      : ShaderInputBase(),
        registry_(NULL),
        index_in_registry_(0),
        registry_id_(0),
        type_(static_cast<ValueType>(0)),
        stamp_(0U),
        array_index_(0) {}

  void SetNewStamp() { stamp_ = GetNewStamp(); }

  template <typename T>
  void Init(const ShaderInputRegistry& registry, size_t registry_id,
            size_t index_in_registry, size_t array_index, ValueType type,
            const T& value) {
    registry_ = &registry;
    registry_id_ = registry_id;
    index_in_registry_ = index_in_registry;
    array_index_ = array_index;
    type_ = type;
    value_.Set(value);
    SetNewStamp();
  }

  template <typename T>
  void InitArray(const ShaderInputRegistry& registry, size_t registry_id,
                 size_t index_in_registry, size_t array_index, ValueType type,
                 const T* values, size_t count,
                 const base::AllocatorPtr& allocator) {
    registry_ = &registry;
    registry_id_ = registry_id;
    index_in_registry_ = index_in_registry;
    array_index_ = array_index;
    type_ = type;
    value_.template InitArray<T>(allocator, count);
    if (values) {
      for (size_t i = 0; i < count; ++i)
        value_.SetValueAt(i, values[i]);
    }
    SetNewStamp();
  }

  const base::AllocatorPtr& GetArrayAllocator() const {
    return value_.GetArrayAllocator();
  }

 private:
  const ShaderInputRegistry* registry_;
  size_t index_in_registry_;
  size_t registry_id_;
  ValueType type_;
  ValueHolderType value_;
  uint64 stamp_;
  size_t array_index_;

  friend class ShaderInputRegistry;
};

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_SHADERINPUT_H_