shaderinputregistry.h

Go to the documentation of this file.

#ifndef ION_GFX_SHADERINPUTREGISTRY_H_
#define ION_GFX_SHADERINPUTREGISTRY_H_

#include <functional>
#include <map>
#include <string>
#include <vector>

#include "base/macros.h"
#include "ion/base/allocator.h"
#include "ion/base/logging.h"
#include "ion/base/referent.h"
#include "ion/base/stlalloc/allocdeque.h"
#include "ion/base/stlalloc/allocmap.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/base/stringutils.h"
#include "ion/base/varianttyperesolver.h"
#include "ion/gfx/attribute.h"
#include "ion/gfx/resourceholder.h"
#include "ion/gfx/uniform.h"

namespace ion {
namespace gfx {

class ShaderInputRegistry;

typedef base::ReferentPtr<ShaderInputRegistry>::Type ShaderInputRegistryPtr;

class ION_API ShaderInputRegistry : public ResourceHolder {
 public:
  enum {
    kUniformAdded = kNumBaseChanges,
    kNumChanges
  };

  template <typename T>
  struct CombineFunction {
    typedef std::function<const T(const T& old_value, const T& new_value)> Type;
  };

  template <typename T>
  struct GenerateFunction {
    typedef std::function<std::vector<T>(const T& current_value)> Type;
  };

  template <typename T>
  struct Spec {
    Spec(const std::string& name_in = std::string(),
         typename T::ValueType value_type_in =
             static_cast<typename T::ValueType>(0),
         const std::string& doc_string_in = std::string(),
         typename CombineFunction<T>::Type combine_function_in = nullptr,
         typename GenerateFunction<T>::Type generate_function_in = nullptr)
        : name(name_in),
          value_type(value_type_in),
          doc_string(doc_string_in),
          index(0),
          registry_id(0),
          registry(NULL),
          combine_function(combine_function_in),
          generate_function(generate_function_in) {}

    std::string name;                  // Name of the shader input argument.
    typename T::ValueType value_type;  // Type of the value of the shader input.
    std::string doc_string;            // String describing its use.
    size_t index;                      // Unique index within registry.
    size_t registry_id;                // Id of the owning registry.
    ShaderInputRegistry* registry;

    typename CombineFunction<T>::Type combine_function;
    typename GenerateFunction<T>::Type generate_function;
  };

  typedef Spec<Attribute> AttributeSpec;
  typedef Spec<Uniform> UniformSpec;

  ShaderInputRegistry();

  size_t GetId() const { return id_; }

  bool Include(const ShaderInputRegistryPtr& reg);

  bool IncludeGlobalRegistry();

  const base::AllocVector<ShaderInputRegistryPtr>& GetIncludes() const {
    return includes_;
  }

  bool CheckInputsAreUnique() const;

  template <typename T> bool Add(const Spec<T>& spec) {
    size_t array_index = 0;
    std::string name;
    if (Contains(spec.name)) {
      LOG(WARNING) << "Can't add " << T::GetShaderInputTypeName() << " spec"
                   << " for '" << spec.name << "': already present in registry"
                   << " or its includes";
      return false;
    } else if (!ParseShaderInputName(spec.name, &name, &array_index)) {
      LOG(WARNING) << "Can't add " << T::GetShaderInputTypeName() << " spec"
                   << " for '" << spec.name << "': invalid input name.";
      return false;
    } else {
      base::AllocDeque<Spec<T> >& specs = *GetMutableSpecs<T>();
      const size_t index = specs.size();
      specs.push_back(spec);
      specs.back().index = index;
      specs.back().registry_id = id_;
      specs.back().registry = this;
      UpdateLargestRegistrySize(specs.size());
      spec_map_[spec.name] = SpecMapEntry(T::GetTag(), index, id_);
      return true;
    }
  }

  bool Contains(const std::string& name) const;

  template <typename T> const Spec<T>* Find(const std::string& name) const {
    const size_t num_includes = includes_.size();
    for (size_t i = 0; i < num_includes; ++i) {
      const Spec<T>* spec = includes_[i]->Find<T>(name);
      if (spec)
        return spec;
    }
    const SpecMapType::const_iterator it = spec_map_.find(name);
    if (it == spec_map_.end()) {
      return NULL;
    } else if (it->second.tag != T::GetTag()) {
      return NULL;
    } else {
      return &GetSpecs<T>()[it->second.index];
    }
  }

  template <typename T> const base::AllocDeque<Spec<T> >& GetSpecs() const;

  template <typename ShaderInputType, typename T>
  const ShaderInputType Create(const std::string& name_in, const T& value) {
    typedef typename base::VariantTypeResolver<
      typename ShaderInputType::HolderType, T>::Type StoredType;
    typename ShaderInputType::ValueType value_type =
        ShaderInputType::template GetTypeByValue<StoredType>();
    std::string name;
    ShaderInputType input;
    size_t index = 0, registry_id = 0, array_index = 0;
    ShaderInputRegistry* registry = NULL;
    if (ParseShaderInputName(name_in, &name, &array_index)) {
      if (!Find<ShaderInputType>(name))
        Add<ShaderInputType>(Spec<ShaderInputType>(name, value_type));
      if (ValidateNameAndType<ShaderInputType>(name, value_type, 0U, &registry,
                                               &registry_id, &index))
        input.template Init<T>(*registry, registry_id, index, array_index,
                               value_type, value);
    }
    return input;
  }
  template <typename ShaderInputType, typename T>
  const ShaderInputType Create(const std::string& name_in,
                               const T& value) const {
    typedef typename base::VariantTypeResolver<
      typename ShaderInputType::HolderType, T>::Type StoredType;
    typename ShaderInputType::ValueType value_type =
        ShaderInputType::template GetTypeByValue<StoredType>();
    std::string name;
    ShaderInputType input;
    size_t index = 0, registry_id = 0, array_index = 0;
    ShaderInputRegistry* registry = NULL;
    if (ParseShaderInputName(name_in, &name, &array_index) &&
        ValidateNameAndType<ShaderInputType>(name, value_type, 0U, &registry,
                                             &registry_id, &index))
        input.template Init<T>(*registry, registry_id, index, array_index,
                               value_type, value);
    return input;
  }

  template <typename T>
  const Uniform CreateArrayUniform(const std::string& name_in, const T* values,
                                   size_t count,
                                   const base::AllocatorPtr& allocator) {
    typedef typename base::VariantTypeResolver<UniformValueType, T>::Type
        StoredType;
    Uniform input;
    size_t index = 0, registry_id = 0, array_index = 0;
    ShaderInputRegistry* registry = NULL;
    UniformType value_type = Uniform::GetTypeByValue<StoredType>();
    std::string name;
    if (ParseShaderInputName(name_in, &name, &array_index)) {
      if (!Find<Uniform>(name)) Add<Uniform>(Spec<Uniform>(name, value_type));
      ValidateNameAndType<Uniform>(name, value_type, count, &registry,
                                   &registry_id, &index);
      input.template InitArray<T>(*registry, registry_id, index, array_index,
                                  value_type, values, count, allocator);
    }
    return input;
  }
  template <typename T>
  const Uniform CreateArrayUniform(const std::string& name_in, const T* values,
                                   size_t count,
                                   const base::AllocatorPtr& allocator) const {
    typedef typename base::VariantTypeResolver<UniformValueType, T>::Type
        StoredType;
    Uniform input;
    size_t index = 0, registry_id = 0, array_index = 0;
    ShaderInputRegistry* registry = NULL;
    UniformType value_type = Uniform::GetTypeByValue<StoredType>();
    std::string name;
    if (ParseShaderInputName(name_in, &name, &array_index) &&
        ValidateNameAndType<Uniform>(name, value_type, count, &registry,
                                     &registry_id, &index))
      input.template InitArray<T>(*registry, registry_id, index, array_index,
                                  value_type, values, count, allocator);
    return input;
  }

  template <typename T>
  static const Spec<T>* GetSpec(const T& input) {
    return !input.IsValid() ? NULL :
        &input.GetRegistry().template GetSpecs<T>()[input.GetIndexInRegistry()];
  }

  static const ShaderInputRegistryPtr& GetGlobalRegistry();

 protected:
  ~ShaderInputRegistry() override;

 private:
  class StaticData;
  class StaticGlobalRegistryData;

  static StaticData* GetStaticData();

  static StaticGlobalRegistryData* GetStaticGlobalRegistryData();

  static void UpdateLargestRegistrySize(size_t size);

  struct SpecMapEntry {
    SpecMapEntry()
        : tag(ShaderInputBase::kUniform),
          index(0),
          registry_id(0) {}

    SpecMapEntry(const ShaderInputBase::Tag& tag_in, size_t index_in,
                 size_t registry_id_in)
        : tag(tag_in),
          index(index_in),
          registry_id(registry_id_in) {}

    ShaderInputBase::Tag tag;
    size_t index;
    size_t registry_id;
  };
  typedef base::AllocMap<const std::string, SpecMapEntry> SpecMapType;

  const SpecMapType GetAllSpecEntries() const;

  template <typename T>
  base::AllocDeque<Spec<T> >* GetMutableSpecs();

  template <typename T>
  bool ValidateNameAndType(const std::string& name,
                           const typename T::ValueType value_type, size_t size,
                           ShaderInputRegistry** registry, size_t* registry_id,
                           size_t* index) const {
    DCHECK(index);
    if (const Spec<T>* spec = Find<T>(name)) {
      if (spec->value_type == value_type) {
        *index = spec->index;
        *registry_id = spec->registry_id;
        *registry = spec->registry;
        return true;
      } else {
        LOG(ERROR) << "Can't create " << T::GetShaderInputTypeName() << " '"
                   << name << "': wrong value_type (got "
                   << T::GetValueTypeName(value_type) << ", expected "
                   << T::GetValueTypeName(spec->value_type) << ")";
        return false;
      }
    } else {
      LOG(ERROR) << "Can't create " << T::GetShaderInputTypeName() << " '"
                 << name << "': no Spec exists for this name, did you forget "
                 << "to Add() it?";
      return false;
    }
  }

  bool ParseShaderInputName(const std::string& input, std::string* name,
                            size_t* index) const {
    *index = 0;
    name->clear();
    const size_t open_pos = input.find("[");
    const size_t close_pos = input.find("]");
    if (open_pos != std::string::npos && close_pos != std::string::npos &&
        close_pos > open_pos + 1U) {
      const std::vector<std::string> tokens = base::SplitString(input, "[]");
      *name = tokens[0];
      if (tokens.size() > 1 && !tokens[1].empty())
        *index = base::StringToInt32(tokens[1]);
    } else if (open_pos == std::string::npos &&
               close_pos == std::string::npos) {
      *name = input;
    } else {
      return false;
    }
    return true;
  }


  Field<base::AllocDeque<UniformSpec> > uniform_specs_;
  base::AllocDeque<AttributeSpec> attribute_specs_;

  base::AllocVector<ShaderInputRegistryPtr> includes_;

  SpecMapType spec_map_;

  size_t id_;

  DISALLOW_COPY_AND_ASSIGN(ShaderInputRegistry);
};

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_SHADERINPUTREGISTRY_H_