shadersourcecomposer.h

Go to the documentation of this file.

#ifndef ION_GFXUTILS_SHADERSOURCECOMPOSER_H_
#define ION_GFXUTILS_SHADERSOURCECOMPOSER_H_

#include <chrono>  // NOLINT
#include <functional>
#include <memory>
#include <string>
#include <vector>

#include "ion/base/referent.h"

namespace ion {
namespace gfxutils {



class ION_API ShaderSourceComposer : public base::Referent {
 public:
  virtual const std::string GetSource() = 0;
  virtual bool DependsOn(const std::string& dependency) const = 0;
  virtual const std::string GetDependencySource(
      const std::string& dependency) const = 0;
  virtual bool SetDependencySource(const std::string& dependency,
                                   const std::string& source) = 0;
  virtual const std::string GetDependencyName(unsigned int id) const = 0;
  virtual const std::vector<std::string> GetDependencyNames() const = 0;
  virtual const std::vector<std::string> GetChangedDependencies() = 0;

 protected:
  ShaderSourceComposer();
  ~ShaderSourceComposer() override;
};
typedef base::ReferentPtr<ShaderSourceComposer>::Type ShaderSourceComposerPtr;



class ION_API StringComposer : public ShaderSourceComposer {
 public:
  explicit StringComposer(const std::string& dependency_name,
                          const std::string& source)
      : dependency_(dependency_name),
        source_(source) {}

  const std::string GetSource() override { return source_; }
  bool DependsOn(const std::string& dependency) const override {
    return dependency == dependency_;
  }
  const std::string GetDependencySource(
      const std::string& dependency) const override {
    return dependency == dependency_ ? source_ : std::string();
  }
  bool SetDependencySource(const std::string& dependency,
                           const std::string& source) override {
    if (dependency == dependency_) {
      source_ = source;
      return true;
    } else {
      return false;
    }
  }
  const std::string GetDependencyName(unsigned int id) const override {
    return dependency_;
  }
  const std::vector<std::string> GetDependencyNames() const override {
    std::vector<std::string> names;
    names.push_back(dependency_);
    return names;
  }
  const std::vector<std::string> GetChangedDependencies() override {
    return std::vector<std::string>();
  }

 protected:
  ~StringComposer() override {}

 private:
  std::string dependency_;
  std::string source_;
};
typedef base::ReferentPtr<StringComposer>::Type StringComposerPtr;



class ION_API FilterComposer : public ShaderSourceComposer {
 public:
  typedef std::function<std::string(const std::string)> StringFilter;
  FilterComposer(const ShaderSourceComposerPtr& base,
                    const StringFilter& transformer)
      : base_(base),
        transformer_(transformer) {}
  const std::string GetSource() override {
    return transformer_(base_->GetSource());
  }
  bool DependsOn(const std::string& dependency) const override {
    return base_->DependsOn(dependency);
  }
  const std::string GetDependencySource(
      const std::string& dependency) const override {
    return base_->GetDependencySource(dependency);
  }
  bool SetDependencySource(const std::string& dependency,
                           const std::string& source) override {
    return base_->SetDependencySource(dependency, source);
  }
  const std::string GetDependencyName(unsigned int id) const override {
    return base_->GetDependencyName(id);
  }
  const std::vector<std::string> GetDependencyNames() const override {
    return base_->GetDependencyNames();
  }
  const std::vector<std::string> GetChangedDependencies() override {
    return base_->GetChangedDependencies();
  }

 private:
  ShaderSourceComposerPtr base_;
  StringFilter transformer_;
};
typedef base::ReferentPtr<FilterComposer>::Type FilterComposerPtr;



class ION_API IncludeComposer : public ShaderSourceComposer {
 public:
  typedef std::function<const std::string(const std::string& name)>
      SourceLoader;
  typedef std::function<bool(const std::string& name,  // NOLINT
                             const std::string& source)> SourceSaver;
  typedef std::function<bool(const std::string& filename,
                             std::chrono::system_clock::time_point* timestamp)>
      SourceModificationTime;

  IncludeComposer(const std::string& filename,
                  const SourceLoader& source_loader,
                  const SourceSaver& source_saver,
                  const SourceModificationTime& source_time,
                  bool insert_line_directives);
  void SetBasePath(const std::string& path);

  const std::string GetSource() override;
  bool DependsOn(const std::string& dependency) const override;
  const std::string GetDependencySource(
      const std::string& dependency) const override;
  bool SetDependencySource(const std::string& dependency,
                           const std::string& source) override;
  const std::string GetDependencyName(unsigned int id) const override;
  const std::vector<std::string> GetDependencyNames() const override;
  const std::vector<std::string> GetChangedDependencies() override;

 protected:
  ~IncludeComposer() override;

 private:
  class IncludeComposerHelper;
  std::unique_ptr<IncludeComposerHelper> helper_;
};
typedef base::ReferentPtr<IncludeComposer>::Type IncludeComposerPtr;



class ION_API ZipAssetComposer : public IncludeComposer {
 public:
  ZipAssetComposer(const std::string& filename, bool insert_line_directives);

 protected:
  ~ZipAssetComposer() override;
};
typedef base::ReferentPtr<ZipAssetComposer>::Type ZipAssetComposerPtr;

}  // namespace gfxutils
}  // namespace ion

#endif  // ION_GFXUTILS_SHADERSOURCECOMPOSER_H_