uniformholder.h

Go to the documentation of this file.

#ifndef ION_GFX_UNIFORMHOLDER_H_
#define ION_GFX_UNIFORMHOLDER_H_

#include <string>

#include "ion/base/allocatable.h"
#include "ion/base/invalid.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/gfx/uniform.h"

namespace ion {
namespace gfx {

class ION_API UniformHolder {
 public:
  size_t AddUniform(const Uniform& uniform) {
    if (uniform.IsValid()) {
      uniforms_.push_back(uniform);
      return uniforms_.size() - 1U;
    } else {
      return base::kInvalidIndex;
    }
  }

  bool ReplaceUniform(size_t index, const Uniform& uniform) {
    if (uniform.IsValid() && index < uniforms_.size()) {
      uniforms_[index] = uniform;
      return true;
    } else {
      return false;
    }
  }

  bool RemoveUniformByName(const std::string& name) {
    const size_t index = GetUniformIndex(name);
    if (index == base::kInvalidIndex)
      return false;
    uniforms_.erase(uniforms_.begin() + index);
    return true;
  }

  void ClearUniforms() { uniforms_.clear(); }

  const base::AllocVector<Uniform>& GetUniforms() const { return uniforms_; }

  template <typename T> bool SetUniformValue(size_t index, const T& value) {
    if (index < uniforms_.size())
      return uniforms_[index].SetValue(value);
    return false;
  }

  template <typename T> bool SetUniformValueAt(size_t index,
                                               size_t array_index,
                                               const T& value) {
    if (index < uniforms_.size())
      return uniforms_[index].SetValueAt(array_index, value);
    return false;
  }

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

  template <typename T> bool SetUniformByName(const std::string& name,
                                              const T& value) {
    const size_t index = GetUniformIndex(name);
    return index == base::kInvalidIndex ? false :
        SetUniformValue<T>(index, value);
  }

  template <typename T> bool SetUniformByNameAt(const std::string& name,
                                                size_t array_index,
                                                const T& value) {
    const size_t index = GetUniformIndex(name);
    return (index == base::kInvalidIndex || index >= uniforms_.size()) ?
        false :
        uniforms_[index].SetValueAt(array_index, value);
  }

  void Enable(bool enable) { is_enabled_ = enable; }
  bool IsEnabled() const { return is_enabled_; }

 protected:
  explicit UniformHolder(const base::AllocatorPtr& alloc);

  virtual ~UniformHolder();

 private:
  bool is_enabled_;
  base::AllocVector<Uniform> uniforms_;
};

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_UNIFORMHOLDER_H_