shadersourcecomposer.cc

Go to the documentation of this file.

#include "ion/gfxutils/shadersourcecomposer.h"

#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>

#include "ion/base/allocatable.h"
#include "ion/base/invalid.h"
#include "ion/base/stlalloc/allocmap.h"
#include "ion/base/stlalloc/allocset.h"
#include "ion/base/stringutils.h"
#include "ion/base/zipassetmanager.h"

namespace ion {
namespace gfxutils {

namespace {

static bool SetAndSaveZipAssetData(const std::string& filename,
                                   const std::string& source) {
  return base::ZipAssetManager::SetFileData(filename, source) &&
      base::ZipAssetManager::SaveFileData(filename);
}

static const std::string GetZipAssetFileData(const std::string& filename) {
  const std::string& data = base::ZipAssetManager::GetFileData(filename);
  return base::IsInvalidReference(data) ? std::string() : data;
}

}  // anonymous namespace



class IncludeComposer::IncludeComposerHelper : public base::Allocatable {
 public:
  IncludeComposerHelper(const base::Allocatable& owner,
                        const std::string& filename,
                        const SourceLoader& source_loader,
                        const SourceSaver& source_saver,
                        const SourceModificationTime& source_time,
                        bool insert_line_directives)
      : file_to_id_(owner),
        id_to_file_(owner),
        filename_(filename),
        source_loader_(source_loader),
        source_saver_(source_saver),
        source_time_(source_time),
        insert_line_directives_(insert_line_directives),
        used_files_(owner) {
    const size_t pos = filename_.rfind('/');
    if (pos != std::string::npos) {
      search_path_ = filename_.substr(0, pos);
      filename_ = filename_.substr(pos + 1, std::string::npos);
    }
  }

  void SetBasePath(const std::string& path) {
    base_path_ = path;
  }

  const std::vector<std::string> GetChangedDependencies() {
    std::vector<std::string> changed;
    for (FileInfoMap::iterator it = used_files_.begin();
        it != used_files_.end(); ++it) {
      std::chrono::system_clock::time_point timestamp;
      const bool found = source_time_(it->first, &timestamp);
      if (found && timestamp > it->second.timestamp) {
        it->second.timestamp = timestamp;
        changed.push_back(it->first);
      }
    }
    return changed;
  }

  const std::string GetSource() {
    std::stack<InputInfo> stack;
    std::set<std::string> file_names;
    std::vector<std::string> output_source;

    unsigned int input_id = 1;

    file_to_id_.clear();
    id_to_file_.clear();
    used_files_.clear();

    stack.push(InputInfo(BuildFilename(filename_)));
    while (!stack.empty()) {
      InputInfo info = stack.top();
      stack.pop();
      if (info.lines.size() == 0) {
        if (file_names.count(info.name) != 0) {
          LOG(WARNING) << stack.top().name << ":" << (stack.top().line - 1U)
                       << ": Recursive $input ignored while trying to $input"
                       << " \"" << info.name << "\".\n";
          continue;
        }

        const std::string source = source_loader_(info.name);
        if (source.empty())
          continue;

        info.lines.push_back("");
        const std::vector<std::string> lines =
            base::SplitStringWithoutSkipping(source, "\n");
        info.lines.insert(info.lines.end(), lines.begin(), lines.end());

        file_names.insert(info.name);
        std::chrono::system_clock::time_point timestamp;
        source_time_(info.name, &timestamp);
        used_files_[info.name] = FileInfo(timestamp);

        if (file_to_id_.count(info.name) == 0) {
          file_to_id_[info.name] = input_id;
          id_to_file_[input_id] = info.name;
        }
        input_id++;

        info.id = file_to_id_[info.name];
        info.line = 1U;

        if (insert_line_directives_ && !stack.empty()) {
          output_source.push_back(GetLineDirectiveString(1, info.id));
        }
      } else if (insert_line_directives_) {
        output_source.push_back(GetLineDirectiveString(info.line - 1, info.id));
      }
      if (ParseInputLines(&stack, &info, &output_source)) {
        file_names.erase(info.name);
      }
    }

    return base::JoinStrings(output_source, "\n");
  }

  const std::string GetDependencySource(const std::string& dependency) {
    if (DependsOn(dependency)) {
      source_time_(dependency, &used_files_[dependency].timestamp);
      return source_loader_(dependency);
    } else {
      return std::string();
    }
  }

  bool SetDependencySource(const std::string& dependency,
                           const std::string& source) {
    if (DependsOn(dependency)) {
      const bool ret = source_saver_(dependency, source);
      source_time_(dependency, &used_files_[dependency].timestamp);
      return ret;
    } else {
      return false;
    }
  }

  bool DependsOn(const std::string& dependency) const {
    return file_to_id_.find(dependency) != file_to_id_.end();
  }

  const std::string GetDependencyName(unsigned int id) const {
    std::string name;
    IdToFileMap::const_iterator it = id_to_file_.find(id);
    if (it != id_to_file_.end())
      name = it->second;
    return name;
  }

  const std::vector<std::string> GetDependencyNames() const {
    std::vector<std::string> names(file_to_id_.size());
    size_t i = 0;
    for (FileToIdMap::const_iterator it = file_to_id_.begin();
         it != file_to_id_.end(); ++it, ++i)
      names[i] = it->first;
    return names;
  }

 private:
  struct InputInfo {
    explicit InputInfo(const std::string& file_name)
        : name(file_name), lines(), id(-1), line(-1) {}
    std::string name;
    std::vector<std::string> lines;
    int id;
    size_t line;
  };

  struct FileInfo {
    FileInfo() {}
    explicit FileInfo(std::chrono::system_clock::time_point timestamp)
        : timestamp(timestamp) {}
    std::chrono::system_clock::time_point timestamp;
  };

  typedef base::AllocMap<std::string, unsigned int> FileToIdMap;
  typedef base::AllocMap<unsigned int, std::string> IdToFileMap;
  typedef base::AllocMap<std::string, FileInfo> FileInfoMap;

  const std::string BuildFilename(const std::string& filename) {
    const std::string base_path = base_path_.empty() ?
        "" : base_path_ + '/';
    const std::string search_path = search_path_.empty() ?
        "" : search_path_ + '/';
    return base_path + search_path + filename;
  }

  std::string GetLineDirectiveString(size_t line, unsigned int file_id) {
    std::stringstream str;
    str << "#line " << line << " " << file_id;
    return str.str();
  }

  bool ParseInputLines(std::stack<InputInfo>* stack, InputInfo* info,
                       std::vector<std::string>* output_lines) {
    for (; info->line < info->lines.size(); ++info->line) {
      const std::string trimmed =
          base::TrimStartAndEndWhitespace(info->lines[info->line]);
      if (base::StartsWith(trimmed, "$input")) {
        const size_t start_pos = trimmed.find("\"") + 1;
        const size_t end_pos = trimmed.find_last_of("\"");
        const std::string input_file =
            trimmed.substr(start_pos, end_pos - start_pos);
        const InputInfo new_info(BuildFilename(input_file));
        if (new_info.name.empty()) {
          LOG(WARNING) << info->name << ":" << info->line
                       << ": Invalid $input directive, perhaps missing a '\"'?";
          continue;
        } else {
          ++info->line;  // Mark $input line as parsed.
          stack->push(*info);
          stack->push(new_info);
          return false;
        }
      } else {
        output_lines->push_back(info->lines[info->line]);
        if (insert_line_directives_) {
          if (trimmed.find("#if") != std::string::npos ||
              trimmed.find("#el") != std::string::npos ||
              trimmed.find("#endif") != std::string::npos)
            output_lines->push_back(
                GetLineDirectiveString(info->line, info->id));
        }
      }
    }
    return true;
  }

  FileToIdMap file_to_id_;
  IdToFileMap id_to_file_;

  std::string filename_;
  std::string search_path_;
  std::string base_path_;
  SourceLoader source_loader_;
  SourceSaver source_saver_;
  SourceModificationTime source_time_;
  bool insert_line_directives_;
  FileInfoMap used_files_;
};



ShaderSourceComposer::ShaderSourceComposer() {}

ShaderSourceComposer::~ShaderSourceComposer() {}



IncludeComposer::IncludeComposer(
    const std::string& filename, const SourceLoader& source_loader,
    const SourceSaver& source_saver, const SourceModificationTime& source_time,
    bool insert_line_directives)
    : helper_(new(GetAllocator()) IncludeComposerHelper(
          *this, filename, source_loader, source_saver, source_time,
          insert_line_directives)) {}
IncludeComposer::~IncludeComposer() {}

void IncludeComposer::SetBasePath(const std::string& path) {
  helper_->SetBasePath(path);
}

const std::vector<std::string> IncludeComposer::GetChangedDependencies() {
  return helper_->GetChangedDependencies();
}

const std::string IncludeComposer::GetSource() {
  return helper_->GetSource();
}

const std::string IncludeComposer::GetDependencySource(
    const std::string& dependency) const {
  return helper_->GetDependencySource(dependency);
}

bool IncludeComposer::SetDependencySource(const std::string& dependency,
                                          const std::string& source) {
  return helper_->SetDependencySource(dependency, source);
}

bool IncludeComposer::DependsOn(const std::string& resource) const {
  return helper_->DependsOn(resource);
}

const std::string IncludeComposer::GetDependencyName(unsigned int id) const {
  return helper_->GetDependencyName(id);
}

const std::vector<std::string> IncludeComposer::GetDependencyNames() const {
  return helper_->GetDependencyNames();
}



ZipAssetComposer::ZipAssetComposer(const std::string& filename,
                                   bool insert_line_directives)
    : IncludeComposer(filename, GetZipAssetFileData,
                      SetAndSaveZipAssetData,
                      base::ZipAssetManager::UpdateFileIfChanged,
                      insert_line_directives) {}

ZipAssetComposer::~ZipAssetComposer() {}

}  // namespace gfxutils
}  // namespace ion