shadermanager.cc

Go to the documentation of this file.

#include "ion/gfxutils/shadermanager.h"

#include "ion/base/allocatable.h"
#include "ion/base/lockguards.h"
#include "ion/base/stlalloc/allocmap.h"
#include "ion/gfx/resourcemanager.h"
#include "ion/gfx/shaderinputregistry.h"
#include "ion/gfx/shaderprogram.h"
#include "ion/gfxutils/resourcecallback.h"
#include "ion/gfxutils/shadersourcecomposer.h"

namespace ion {
namespace gfxutils {

namespace {

using base::LockGuard;
using gfx::GraphicsManagerPtr;
using gfx::ResourceManager;
using gfx::Shader;
using gfx::ShaderPtr;
using gfx::ShaderProgram;
using gfx::ShaderProgramPtr;

}  // anonymous namespace


class ShaderManager::ShaderManagerData : public base::Allocatable {
 public:
  struct ProgramInfo {
    ProgramInfo() : program(ShaderProgramPtr()) {}
    explicit ProgramInfo(const ShaderProgramPtr& program_in)
        : program(program_in) {}
    gfx::ShaderProgramWeakPtr program;
    ShaderSourceComposerPtr vertex_source_composer;
    ShaderSourceComposerPtr fragment_source_composer;
  };
  typedef base::AllocMap<std::string, ProgramInfo> ProgramMap;

  explicit ShaderManagerData(const base::Allocatable& owner)
      : programs_(owner) {}
  ~ShaderManagerData() override {}

  void AddProgramInfo(const std::string& name, const ProgramInfo& info) {
    LockGuard guard(&mutex_);
    programs_[name] = info;
  }

  const ShaderProgramPtr GetShaderProgram(const std::string& name) {
    LockGuard guard(&mutex_);
    ProgramMap::iterator it = FindProgramInfo(name);
    return GetProgramFromInfo(&it);
  }

  const std::vector<std::string> GetShaderProgramNames() {
    std::vector<std::string> names;
    names.reserve(programs_.size());
    for (ProgramMap::iterator it = programs_.begin(); it != programs_.end();) {
      if (GetProgramFromInfo(&it).Get()) {
        names.push_back(it->first);
        ++it;
      }
    }
    return names;
  }

  void GetShaderProgramComposers(
      const std::string& name, ShaderSourceComposerPtr* vertex_source_composer,
      ShaderSourceComposerPtr* fragment_source_composer) {
    ShaderProgramPtr program;
    LockGuard guard(&mutex_);
    ProgramMap::iterator it = FindProgramInfo(name);
    if (it != programs_.end()) {
      if (vertex_source_composer)
        *vertex_source_composer = it->second.vertex_source_composer;
      if (fragment_source_composer)
        *fragment_source_composer = it->second.fragment_source_composer;
    } else {
      if (vertex_source_composer)
        *vertex_source_composer = NULL;
      if (fragment_source_composer)
        *fragment_source_composer = NULL;
    }
  }

  void RecreateAllShaderPrograms() {
    LockGuard guard(&mutex_);
    for (ProgramMap::iterator it = programs_.begin(); it != programs_.end();) {
      const ShaderProgramPtr& program = GetProgramFromInfo(&it);
      if (program.Get()) {
        const ProgramInfo& info = it->second;
        DCHECK(program.Get());

        if (Shader* shader = program->GetVertexShader().Get())
          shader->SetSource(info.vertex_source_composer->GetSource());
        if (Shader* shader = program->GetFragmentShader().Get())
          shader->SetSource(info.fragment_source_composer->GetSource());
        ++it;
      }
    }
  }

  void RecreateShaderProgramsThatDependOn(const std::string& dependency) {
    LockGuard guard(&mutex_);
    for (ProgramMap::iterator it = programs_.begin(); it != programs_.end();) {
      const ShaderProgramPtr& program = GetProgramFromInfo(&it);
      if (program.Get()) {
        const ProgramInfo& info = it->second;
        if (info.vertex_source_composer->DependsOn(dependency))
          if (Shader* shader = program->GetVertexShader().Get())
            shader->SetSource(info.vertex_source_composer->GetSource());
        if (info.fragment_source_composer->DependsOn(dependency))
          if (Shader* shader = program->GetFragmentShader().Get())
            shader->SetSource(info.fragment_source_composer->GetSource());
        ++it;
      }
    }
  }

 private:
  ProgramMap::iterator FindProgramInfo(const std::string& name) {
    ProgramMap::iterator it = programs_.find(name);
    if (!GetProgramFromInfo(&it).Get())
      it = programs_.end();
    return it;
  }

  const ShaderProgramPtr GetProgramFromInfo(ProgramMap::iterator* it) {
    ShaderProgramPtr program;
    if ((*it) != programs_.end()) {
      program = (*it)->second.program.Acquire();
      if (!program.Get()) {
        *it = programs_.erase(*it);
      }
    }
    return program;
  }

  ProgramMap programs_;

  port::Mutex mutex_;
};

ShaderManager::ShaderManager()
    : data_(new(GetAllocator()) ShaderManagerData(*this)) {}

ShaderManager::~ShaderManager() {}

const ShaderProgramPtr ShaderManager::CreateShaderProgram(
    const std::string& name, const ion::gfx::ShaderInputRegistryPtr& registry,
    const ShaderSourceComposerPtr& vertex_source_composer,
    const ShaderSourceComposerPtr& fragment_source_composer) {
  ShaderProgramPtr program(new(GetAllocatorForLifetime(base::kMediumTerm))
                           ion::gfx::ShaderProgram(registry));
  ShaderManagerData::ProgramInfo info(program);
  program->SetLabel(name);
  program->SetVertexShader(
      ShaderPtr(new(GetAllocatorForLifetime(base::kMediumTerm))
                Shader(vertex_source_composer->GetSource())));
  program->GetVertexShader()->SetLabel(name + " vertex shader");
  program->SetFragmentShader(
      ShaderPtr(new(GetAllocatorForLifetime(base::kMediumTerm))
                Shader(fragment_source_composer->GetSource())));
  program->GetFragmentShader()->SetLabel(name + " fragment shader");
  info.vertex_source_composer = vertex_source_composer;
  info.fragment_source_composer = fragment_source_composer;
  data_->AddProgramInfo(name, info);

  return program;
}

const ShaderProgramPtr ShaderManager::GetShaderProgram(
    const std::string& name) {
  return data_->GetShaderProgram(name);
}

const std::vector<std::string> ShaderManager::GetShaderProgramNames() {
  return data_->GetShaderProgramNames();
}

void ShaderManager::GetShaderProgramComposers(
    const std::string& name,
    ShaderSourceComposerPtr* vertex_source_composer,
    ShaderSourceComposerPtr* fragment_source_composer) {
  data_->GetShaderProgramComposers(name, vertex_source_composer,
                                   fragment_source_composer);
}

void ShaderManager::RecreateAllShaderPrograms() {
  data_->RecreateAllShaderPrograms();
}

void ShaderManager::RecreateShaderProgramsThatDependOn(
    const std::string& dependency) {
  data_->RecreateShaderProgramsThatDependOn(dependency);
}

}  // namespace gfxutils
}  // namespace ion