SimpleMultiPassFragmentShader.cpp

/*
 * SimpleMultiPassFragmentShader.cpp
 *
 *  Created on: Feb 26, 2009
 *      Author: africk
 */

#include "SimpleMultiPassFragmentShader.hh"

using namespace std;
using namespace BIAS;

SimpleMultiPassFragmentShader::SimpleMultiPassFragmentShader()
{
  initialized_ = false;
  createdGLContext_ = false;
}

void
SimpleMultiPassFragmentShader::Init(bool createGLContext)
{
  if (initialized_)
    {
      Destroy();
    }
  if (createGLContext)
    {
      // setup configuration
      glfRenderingContextConfig cfg;
      cfg.width = 1; // size does not matter!
      cfg.height = 1; // size does not matter!
      cfg.doubleBuffer = 0;
      cfg.redSize = 8;
      cfg.greenSize = 8;
      cfg.blueSize = 8;
      cfg.alphaSize = 8;
      cfg.depthSize = 24;
      cfg.stencilSize = 0;
      pbuffer_.Init(cfg);
      createdGLContext_ = true;
    }
  else
    {
      createdGLContext_ = false;
    }

  framebuffer_setup_pool_.Create(texture_pool_);

  InitBatch_();
  InitPrimitiveData_();
  InitVertexTransformation_();

  initialized_ = true;
}

void
SimpleMultiPassFragmentShader::Destroy()
{
  shader_pool_.ClearAll();
  framebuffer_setup_pool_.ClearAll();
  texture_pool_.ClearAll();
  input_textures_.clear();

  if (createdGLContext_)
    {
      pbuffer_.Destroy();
    }
  else
    {
      createdGLContext_ = false;
    }

  depthTest_.clear();  
  postActions_.clear();

  initialized_ = false;

}

void
SimpleMultiPassFragmentShader::AddFragmentShaderFromFile(
    const string& shader_path, const string& shader_name)
{
  if (initialized_)
    {
      //the name of the program and shader are equal
      try {
        shader_pool_.AddShaderProgram(shader_name);
        shader_pool_.AddFragmentShaderFromFile(shader_path, shader_name,
          shader_name);

        shader_pool_.LinkAll();
      } catch(glfException& e) {
        BIASERR("error adding shader : "<<shader_name<<" from file : "<<shader_path<<endl);
        throw e;
      }
    }
  else
    {
        GLF_THROW_EXCEPTION("call Init first !" << endl);
    }
}

void
SimpleMultiPassFragmentShader::AddFragmentShader(const string& shader_source,
    const string& shader_name)
{
  if (initialized_)
    {
      //the name of the program and shader are equal
      shader_pool_.AddShaderProgram(shader_name);
      shader_pool_.AddFragmentShader(shader_source, shader_name, shader_name);
      shader_pool_.LinkAll();
    }
  else
    {
        GLF_THROW_EXCEPTION("call Init first !" << endl);
    }
}

template<class StorageType>
  void
  SimpleMultiPassFragmentShader::SetShaderVariable(const string& shader_name,
      const string& var_name, StorageType value)
  {
    string type = shader_pool_.GetUniformType(shader_name, var_name);
    if (type.compare("sampler2D") == 0)
      {
          GLF_THROW_EXCEPTION("variable with name " << var_name << " is a texture (sampler2D), use SetOutputTextures / SetInputTextures to set textures " << endl);
      }
    else
      {
        shader_pool_.SetUniform(shader_name, var_name, value);
      }
  }

void
SimpleMultiPassFragmentShader::LoadTexture(const ImageBase& image,
    const string& texture_name, GLenum minFilter, GLenum magFilter,
    GLenum wrapS, GLenum wrapT, GLenum internalFormat, int mipmap)
{
  if (initialized_)
    {
      texture_pool_.UploadImage(texture_name, image, minFilter, magFilter,
          wrapS, wrapT, internalFormat, mipmap);
    }
  else
    {
        GLF_THROW_EXCEPTION("call Init first !" << endl);
    }
}

void
SimpleMultiPassFragmentShader::CreateTexture(int width, int height, 
                                             GLenum internalFormat, const std::string& texture_name,
                                             GLenum minFilter, GLenum magFilter,
                                             GLenum wrapS, GLenum wrapT, int mipmap)
{
if (initialized_)
    {
      texture_pool_.Create(texture_name, width, height, internalFormat, 
        minFilter, magFilter, wrapS, wrapT, mipmap);
    }
  else
    {
        GLF_THROW_EXCEPTION("call Init first !" << endl);
    }
}

void
SimpleMultiPassFragmentShader::CreateTexture(int width, int height,
    ImageBase::EStorageType storageType, ImageBase::EColorModel colorModel,
    const string& texture_name, GLenum minFilter, GLenum magFilter,
    GLenum wrapS, GLenum wrapT, int mipmap)
{
  if (initialized_)
    {
      texture_pool_.Create(texture_name, width, height, storageType,
          colorModel, minFilter, magFilter, wrapS, wrapT, mipmap);
    }
  else
    {
        GLF_THROW_EXCEPTION("call Init first !" << endl);
    }
}

void
SimpleMultiPassFragmentShader::SetInputTextures(const string& shader_name,
    const vector<string>& samplers2D, const vector<string>& texture_names)
{
  //TODO check if an output texture with this name exists
  BIASASSERT(samplers2D.size() == texture_names.size());
  if (initialized_)
    {
      shader_pool_.LinkAll();

      glfShaderProgram* programP = shader_pool_.GetShaderProgram(shader_name);
      if (programP == NULL)
        {
            GLF_THROW_EXCEPTION("no shader with name: " << shader_name
                << " exists." << endl);
        }
      else
        {
          vector<pair<glfTexture*, pair<string, string> > > textures(
              samplers2D.size());
          for (unsigned int i = 0; i < samplers2D.size(); i++)
            {
              glfTexture2D* textureP = texture_pool_[texture_names[i]];
              if (textureP == NULL)
                {
                    GLF_THROW_EXCEPTION("no texture with name: " << texture_names[i]
                        << " exists." << endl);
                }
              else
                {
                  textures[i] = make_pair(textureP, make_pair(samplers2D[i],
                      texture_names[i]));
                }
            }
          SetInputTextures_(shader_name, textures);
        }
    }
  else
    {
        BIASERR("call Init first !" << endl);
        BIASABORT;
    }
}

void
SimpleMultiPassFragmentShader::SetInputTextures(const std::string& shaderName, const std::string& uniformVarName,
            const std::string& texturePoolName)
{
  if (initialized_)
  {
    shader_pool_.LinkAll();

    glfShaderProgram* programP = shader_pool_.GetShaderProgram(shaderName);
    if (programP == NULL)
    {
      GLF_THROW_EXCEPTION("no shader with name: " << shaderName
        << " exists." << endl);
    }
    else
    {
      vector<pair<glfTexture*, pair<string, string> > > textures(1);
      
        glfTexture2D* textureP = texture_pool_[texturePoolName];
        if (textureP == NULL)
        {
          GLF_THROW_EXCEPTION("no texture with name: " << texturePoolName
          << " exists." << endl);
        }
        else
        {
          textures[0] = make_pair(textureP, make_pair(uniformVarName, texturePoolName));
        }
      
      SetInputTextures_(shaderName, textures);
    }
  }
  else
  {
    BIASERR("call Init first !" << endl);
    BIASABORT;
  }
}

vector<pair<glfTexture*, pair<string, string> > >*
SimpleMultiPassFragmentShader::GetInputTextures_(const string& shader_name)
{
  map<string, vector<pair<glfTexture*, pair<string, string> > > >::iterator
      iter = input_textures_.find(shader_name);
  if (iter != input_textures_.end())
    {
      return &(iter->second);
    }
  else
    {
      return NULL;
    }
}

void
SimpleMultiPassFragmentShader::ActivateInputTextures_(
    const string& shader_name,
    vector<pair<glfTexture*, pair<string, string> > >& textures)
{
  for (int i = 0; i < (int) textures.size(); i++)
    {
      glActiveTexture(GL_TEXTURE0+i);
      textures[i].first->Bind();
      shader_pool_.SetUniform(shader_name, (textures[i].second).first, i);
    }
}

void
SimpleMultiPassFragmentShader::SetInputTextures_(const string& shader_name,
    vector<pair<glfTexture*, pair<string, string> > >& textures)
{
  map<string, vector<pair<glfTexture*, pair<string, string> > > >::iterator
      iter = input_textures_.find(shader_name);
  if (iter != input_textures_.end())
    {
      iter->second = textures;
    }
  else
    {
      input_textures_[shader_name] = textures;
    }
}

void
SimpleMultiPassFragmentShader::SetOutputTexture(const string& shader_name,
    const string& colorTextureName, const string& depthTextureName)
{

  //TODO check if an input texture with this name exists
  if (initialized_)
    {
      FramebufferSetup* setupP = framebuffer_setup_pool_.CreateSetup(
          shader_name);
      if (setupP == NULL)
        {
            GLF_THROW_EXCEPTION("no shader with name: " << shader_name
                << " exists." << endl);
        }
      else
        {
          /*vector<string> texture_names(1);
          texture_names[0] = texture_name;
          framebuffer_setup_pool_.SetColorAttachments(shader_name, texture_names);*/
          glfTexture2D* texture = texture_pool_[colorTextureName];
          if(texture==NULL) {
            GLF_THROW_EXCEPTION("cannot attach unexistant texture with name" <<colorTextureName<< endl);
          }
          setupP->ClearColorAttachments();
          setupP->SetColorAttachment(texture);
          if(depthTextureName.size()>0) {
            texture = texture_pool_[depthTextureName];
            if(texture==NULL) {
              GLF_THROW_EXCEPTION("cannot attach unexistant texture with name" <<depthTextureName<< endl);
            }
            setupP->SetDepthAttachment(texture);
          }
          setupP->Execute();//why
        }
    }
  else
    {
        BIASERR("call Init first !" << endl);
        BIASABORT;
    }
}

void
SimpleMultiPassFragmentShader::SetOutputTextures(const string& shader_name,
    const vector<string>& texture_names, const string& depthTextureName)
{

  //TODO check if an input texture with this name exists
  if (initialized_)
    {
      FramebufferSetup* setupP = framebuffer_setup_pool_.CreateSetup(
          shader_name);
      if (setupP == NULL)
        {
            GLF_THROW_EXCEPTION("no shader with name: " << shader_name
                << " exists." << endl);
        }
      else
        {
          // setupP->DisableColorClearance();
          //setupP->DisableDepthClearance();
          framebuffer_setup_pool_.SetColorAttachments(shader_name, texture_names);
          if(depthTextureName.size()>0) {
            glfTexture2D* texture = texture_pool_[depthTextureName];
            if(texture==NULL) {
              GLF_THROW_EXCEPTION("cannot attach unexistant texture with name" <<depthTextureName<< endl);
            }
            setupP->SetDepthAttachment(texture);
          }
          setupP->Execute();
        }
    }
  else
    {
        BIASERR("call Init first !" << endl);
        BIASABORT;
    }
}

void
SimpleMultiPassFragmentShader::CopyToImage(const string& texture_name,
    ImageBase& image)
{
  glfTexture2D* textureP = texture_pool_[texture_name];
  if (textureP == NULL)
    {
        GLF_THROW_EXCEPTION("no texture with name: " << texture_name << " exists !" << endl);
    }
  else
    {
      textureP->CopyToImage(image, 0);
    }
}

void
SimpleMultiPassFragmentShader::CopyChannelsToImage(const string& texture_name,
                                                   GLenum format,
                                                   ImageBase& image)
{
  glfTexture2D* textureP = texture_pool_[texture_name];
  if (textureP == NULL)
    {
        GLF_THROW_EXCEPTION("no texture with name: " << texture_name << " exists !" << endl);
    }
  else
    {
      textureP->CopyChannelsToImage(image, format, 0);
    }
}

SimpleMultiPassFragmentShader::ActionGuard::ActionGuard() : action_(NULL)
{}

SimpleMultiPassFragmentShader::ActionGuard::~ActionGuard()
{
  delete action_;
}

SimpleMultiPassFragmentShader::ActionGuard::ActionGuard(const BIAS::SMPFSActionInterface* action)
{
  action_ = NULL;
  this->operator = (action);
}


void
SimpleMultiPassFragmentShader::ActionGuard::operator =(const BIAS::SMPFSActionInterface* action)
{
  delete action_;
  if(action!=NULL)
    action_ = action->Clone();
  else 
    action_ = NULL;
}

void
SimpleMultiPassFragmentShader::ActionGuard::Execute(const unsigned int& currentIter, const unsigned int& numIter)
{
  if(action_==NULL) {
    BIASERR("fatal implementation error!");
    BIASABORT;
  }
  action_->Execute(currentIter, numIter);
}

 void
SimpleMultiPassFragmentShader::ActionGuard::Reset()
 {
   if(action_==NULL) {
    BIASERR("fatal implementation error!");
    BIASABORT;
  }
  action_->Reset();
 }

SimpleMultiPassFragmentShader::ActionGuard::ActionGuard(const SimpleMultiPassFragmentShader::ActionGuard& a)
{
  action_=NULL;
  this->operator = (a.action_);
}

SimpleMultiPassFragmentShader::ActionGuard& 
SimpleMultiPassFragmentShader::ActionGuard::operator=(const SimpleMultiPassFragmentShader::ActionGuard& a)
{
  this->operator = (a.action_);
  return (*this);
}

void 
SimpleMultiPassFragmentShader::SetPostAction(const std::string& shaderName, const SMPFSActionInterface& postAction)
{
  postActions_[shaderName] = &postAction;
}

void 
SimpleMultiPassFragmentShader::ResetPostAction(const std::string& shaderName)
{
  if(postActions_.find(shaderName)!=postActions_.end())
    postActions_[shaderName].Reset();
}



void 
SimpleMultiPassFragmentShader::ClearPostAction(const std::string& shaderName)
{
  map<std::string, ActionGuard>::iterator it = postActions_.find(shaderName);
  if(it!=postActions_.end()) {
    postActions_.erase(it);
  }
}

void
SimpleMultiPassFragmentShader::Execute(const vector<string>& shader_names,
    unsigned int iter_number)
{

  glfFramebufferObject* fboP = framebuffer_setup_pool_.GetFBO();
  //fboP->CheckComplete();
  batch_.SetRenderTarget(fboP);

  for (unsigned int num = 0; num < iter_number; num++)
    {
      for (unsigned int i = 0; i < shader_names.size(); i++)
        {

          glfShaderProgram* programP = shader_pool_.GetShaderProgram(
              shader_names[i]);

          if (programP == NULL)
            {
                GLF_THROW_EXCEPTION("no program"<< shader_names[i] << " exists !" << endl);
            }

          batch_.SetShaderProgram(programP);

          GLF_THROW_ON_OPENGL_ERROR;
          vector<pair<glfTexture*, pair<string, string> > >* input_texturesP =
              GetInputTextures_(shader_names[i]);

          if (input_texturesP != NULL)
            {
              ActivateInputTextures_(shader_names[i], *input_texturesP);
              for (unsigned int j = 0; j < input_texturesP->size(); j++)
                {
                  batch_.SetTexture(((*input_texturesP)[j]).first, j);
                }
            }

          FramebufferSetup* setupP = framebuffer_setup_pool_.GetSetup(
              shader_names[i]);

          if (setupP == NULL)
            {
                GLF_THROW_EXCEPTION("no output textures for shader "<< shader_names[i] << " specified" << endl);
            }
          glfTexture2D* textureP = setupP->GetColorAttachment2D(0);

          if (textureP == NULL)
            {
                GLF_THROW_EXCEPTION("no output textures for shader "<< shader_names[i] << " specified" << endl);
            }


          framebuffer_setup_pool_.Activate(shader_names[i]);


          viewport_.SetSize(textureP->GetWidth(), textureP->GetHeight());

          
          ActivateDepthTest_(shader_names[i]);


          batch_.Draw();

          map<string, ActionGuard>::iterator postAction = postActions_.find(shader_names[i]);
          if(postAction != postActions_.end()) {
            postAction->second.Execute(num, iter_number);
          }
        }
    }
}

void
SimpleMultiPassFragmentShader::EnableColorClearance(const std::string& shaderName, 
                          float red, float green, float blue, float alpha)
{
  FramebufferSetup* setupP = framebuffer_setup_pool_.GetSetup(shaderName);

  if (setupP == NULL) {
    GLF_THROW_EXCEPTION("no output textures for shader "<< setupP << " spezified" << endl);
  }
  setupP->EnableColorClearance(red, green, blue, alpha);
}


void
SimpleMultiPassFragmentShader::EnableDepthClearance(const std::string& shaderName, float depth)
{
  FramebufferSetup* setupP = framebuffer_setup_pool_.GetSetup(shaderName);

  if (setupP == NULL) {
    GLF_THROW_EXCEPTION("no output textures for shader "<< setupP << " spezified" << endl);
  }
  setupP->EnableDepthClearance(depth);
}


void
SimpleMultiPassFragmentShader::DisableColorClearance(const std::string& shaderName)
{
  FramebufferSetup* setupP = framebuffer_setup_pool_.GetSetup(shaderName);

  if (setupP == NULL) {
    GLF_THROW_EXCEPTION("no output textures for shader "<< setupP << " spezified" << endl);
  }
  setupP->DisableColorClearance();
}


void
SimpleMultiPassFragmentShader::DisableDepthClearance(const std::string& shaderName)
{
  FramebufferSetup* setupP = framebuffer_setup_pool_.GetSetup(shaderName);

  if (setupP == NULL) {
    GLF_THROW_EXCEPTION("no output textures for shader "<< setupP << " spezified" << endl);
  }
  setupP->DisableDepthClearance();
}

void
SimpleMultiPassFragmentShader::SetDepthTest(const std::string& shaderName, const bool enabled, GLenum depthFunc)
{
  depthTest_[shaderName].SetDepthTest(enabled);
  depthTest_[shaderName].SetDepthFunc(depthFunc);  
}

void 
SimpleMultiPassFragmentShader::ActivateDepthTest_(const std::string& shaderName)
{
  map<string, glfDepthBufferMode>::const_iterator it = depthTest_.find(shaderName);
  if(it!=depthTest_.end()) {
    batch_.SetDepthBufferMode(&(it->second));
  } else {
    batch_.SetDepthBufferMode(&glfDepthBufferMode::DEFAULT);
  }
}


void SimpleMultiPassFragmentShader::
EvaluateOnlyPatches(const unsigned int referenceWidth, 
                    const unsigned int referenceHeight,
                    const std::vector<unsigned int>& posX,
                    const std::vector<unsigned int>& posY,
                    const unsigned int hw)
{
  Primitives:: AddRelativeQuadPatches(referenceWidth, referenceHeight,
                                      posX, posY, hw,
                                      vertices_, elements_, false);
}

void SimpleMultiPassFragmentShader::
EvaluateOnlyLine(const unsigned int referenceWidth,
                 const unsigned int referenceHeight,
                 const unsigned int posY,
                 const unsigned int hw)
{
  Primitives:: AddRelativeQuadPatchOverImageLine(referenceWidth, referenceHeight,
                                                 posY, hw,
                                                 vertices_, elements_, false);
}


//bool
//SimpleMultiPassFragmentShader::IsInputTexture_(const string& shader_name, const string& texture_name)
//{
//  vector<string>* texNamesP = GetOutputTextureNames_()
//}
//bool
//SimpleMultiPassFragmentShader::IsOutputTexture_(const string& shader_name, const string& texture_name)
//{
//
//}


//#################################################
template BIASOpenGLFramework_EXPORT void
SimpleMultiPassFragmentShader::SetShaderVariable<int>(
    const string& shader_program_name, const string& varName, int value);
template BIASOpenGLFramework_EXPORT void
SimpleMultiPassFragmentShader::SetShaderVariable<bool>(
    const string& shader_program_name, const string& varName, bool value);
template BIASOpenGLFramework_EXPORT void
SimpleMultiPassFragmentShader::SetShaderVariable<float>(
    const string& shader_program_name, const string& varName, float value);
template BIASOpenGLFramework_EXPORT void
SimpleMultiPassFragmentShader::SetShaderVariable<double>(
    const string& shader_program_name, const string& varName, double value);
template BIASOpenGLFramework_EXPORT void
SimpleMultiPassFragmentShader::SetShaderVariable<Vector<float> >(
    const string& shader_program_name, const string& varName,
    Vector<float> value);