FramebufferSetupPool.cpp

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003-2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <OpenGLFramework/Utils/FramebufferSetupPool.hh>
#include <algorithm>

using namespace BIAS;
using namespace std;

FramebufferSetupPool::~FramebufferSetupPool()
{
  ClearAll();
}

void
FramebufferSetupPool::Create(Texture2DPool& texturePoolP)
{
  texturePoolP_ = &texturePoolP;
  fbo_.Create();
}

/** Create a setup and the required 2D textures.
 * \param setupName is the name used to identify the setup.
 * \param width horizontal resolution.
 * \param width vertical resolution.
 * \param colorAttachmentName name of the glfTexture2D attached to COLOR_ATTACHMENT_0, identifying it in the internal
 *        Texture2DPool, this name must be unique across all setups.
 * \param internalFormat is the internal format of the target glfTexture2D.
 * \param clearColor if true the target texture is cleared when the setup is activated.
 * \param depthAttachmentName if you want to render the depth output to a texture, give it a name for the internal Texture2DPool,
 *  if left empty to texture for the depth is attached, this name must be unique across all setups.
 * \param clearDepth if true the target 'depth textur'e is cleared when the setup is activated.
 * \param *Clear values the different channels are cleared, if clearing is enabled.
 **/
FramebufferSetup*
FramebufferSetupPool::CreateSetup(const std::string& setupName,
    unsigned int width, unsigned int height,
    const std::string& colorAttachmentName, GLenum internalFormat,
    const bool clearColors, const std::string& depthAttachmentName,
    const bool clearDepth, const float rClear, const float gClear,
    const float bClear, const float aClear, const float zClear)
{
  map<std::string, pair<FramebufferSetup*, vector<string> > >::iterator it =
      fboSetupPool_.find(setupName);
  if (it != fboSetupPool_.end())
    {
        BIASERR("already used setup name : " << setupName
            << ". use clear before reusing the name!");
      ClearAll();
        BIASABORT;
    }

  //create attachments
  glfTexture2D* colorAttachment = texturePoolP_->Create(colorAttachmentName,
      width, height, internalFormat);

  FramebufferSetup* newSetup(NULL);
  newSetup = new FramebufferSetup;
  pair<FramebufferSetup*, vector<string> > newPair = make_pair(newSetup,
      vector<string> ());
  newPair.second.push_back(colorAttachmentName); // save attachment name
//   cout<<"adding "<<colorAttachmentName<<endl;
//   for(unsigned int i=0; i<newPair.second.size(); i++){
//     cout<<"appended "<<newPair.second[i]<<endl;
//   }

  glfTexture2D* depthAttachment = NULL;
  if (depthAttachmentName.size() > 0) {
    depthAttachment = texturePoolP_->Create(depthAttachmentName, width, height,
        GL_DEPTH_COMPONENT);
    newPair.second.push_back(depthAttachmentName); // save attachment name
  }


  fboSetupPool_[setupName] = newPair;

  newSetup->LinkFBO(&fbo_);
  newSetup->SetColorAttachment(colorAttachment);
  newSetup->SetDepthAttachment(depthAttachment);

  if (clearColors)
    {
      newSetup->EnableColorClearance(rClear, gClear, bClear, aClear);
    }
  else
    {
      newSetup->DisableColorClearance();
    }
  if (clearDepth)
    {
      newSetup->EnableDepthClearance(zClear);
    }
  else
    {
      newSetup->DisableDepthClearance();
    }
  return newSetup;
}

FramebufferSetup*
FramebufferSetupPool::CreateSetup(const std::string& setupName,
    unsigned int width, unsigned int height,
    const std::vector<std::string>& colorAttachmentNames,
    GLenum internalFormat, const bool clearColors,
    const std::string& depthAttachmentName, const bool clearDepth,
    const float rClear, const float gClear, const float bClear,
    const float aClear, const float zClear)
{
  map<std::string, pair<FramebufferSetup*, vector<string> > >::iterator it =
      fboSetupPool_.find(setupName);
  if (it != fboSetupPool_.end())
    {
        BIASERR("already used setup name : " << setupName
            << ". use clear before reusing the name!");
      ClearAll();
        BIASABORT;
    }

  //create attachments
  FramebufferSetup* newSetup(NULL);
  newSetup = new FramebufferSetup;
  pair<FramebufferSetup*, vector<string> > newPair = make_pair(newSetup,
      vector<string> ());

  newSetup->LinkFBO(&fbo_);
  for (unsigned int i = 0; i < colorAttachmentNames.size(); i++)
    {
      glfTexture2D* colorAttachment = texturePoolP_->Create(
          colorAttachmentNames[i], width, height, internalFormat);
      newSetup->SetColorAttachment(colorAttachment, i);
      newPair.second.push_back(colorAttachmentNames[i]); // save attachment name
    }
  fboSetupPool_[setupName] = newPair;

  //depth attachment
  glfTexture2D* depthAttachment = NULL;
  if (depthAttachmentName.size() > 0) {
    depthAttachment = texturePoolP_->Create(depthAttachmentName, width, height,
        GL_DEPTH_COMPONENT);
      newPair.second.push_back(depthAttachmentName); // save attachment name
  }
  newSetup->SetDepthAttachment(depthAttachment);
  if (clearColors)
    {
      newSetup->EnableColorClearance(rClear, gClear, bClear, aClear);
    }
  else
    {
      newSetup->DisableColorClearance();
    }
  if (clearDepth)
    {
      newSetup->EnableDepthClearance(zClear);
    }
  else
    {
      newSetup->DisableDepthClearance();
    }
  return newSetup;
}

void
FramebufferSetupPool::SetColorAttachments(const string& setupName,
    const vector<string>& colorAttachmentNames)
{
  if (texturePoolP_ != NULL)
    {
      map<string, pair<FramebufferSetup*, vector<string> > >::iterator iter =
          fboSetupPool_.find(setupName);
      if (iter != fboSetupPool_.end())
        {
          FramebufferSetup* fbsP = (iter->second).first;
          (iter->second).second = colorAttachmentNames;
          SetColorAttachments_(*fbsP, colorAttachmentNames);
        }
      else
        {
            BIASERR("no frame buffer setup with name (" << setupName
                << ") found !");
          ClearAll();
            BIASABORT;
        }
    }
  else
    {
        BIASERR("call create first ! " << endl);
        BIASABORT;
    }
}

void
FramebufferSetupPool::SetColorAttachments_(FramebufferSetup& frameBufferSetup,
    const vector<string>& colorAttachmentNames)
{
  vector<glfTexture*> textureVector(colorAttachmentNames.size());
  for (unsigned int i = 0; i < colorAttachmentNames.size(); i++)
    {
      glfTexture2D* textureP = (*texturePoolP_)[colorAttachmentNames[i]];
      if (textureP == NULL)
        {
            BIASERR("unable to attach texture "
                << colorAttachmentNames[i] << " no such texture found "
                << endl);
            BIASABORT;
        }
      else
        {
          textureVector[i] = textureP;
        }
    }

  frameBufferSetup.SetColorAttachments(textureVector);
}

FramebufferSetup*
FramebufferSetupPool::CreateSetup(const std::string& setupName)
{
  FramebufferSetup* newSetup(NULL);
  map<string, pair<FramebufferSetup*, vector<string> > >::iterator iter =
      fboSetupPool_.find(setupName);
  if (iter != fboSetupPool_.end())
    {
        BIASERR("already used setup name : " << setupName
            << ". use clear before reusing the name!");
      ClearAll();
        BIASABORT;
    }
  else
    {
      newSetup = new FramebufferSetup;
      newSetup->LinkFBO(&fbo_);
      fboSetupPool_[setupName] = make_pair(newSetup, vector<string> ());
    }

  return newSetup;
}

void
FramebufferSetupPool::ClearAll()
{
  map<std::string, pair<FramebufferSetup*, vector<string> > >::iterator it =
    fboSetupPool_.begin();
  for (; it != fboSetupPool_.end(); it++)
    {
      delete (it->second).first;
    }
  fboSetupPool_.clear();
  //texturePoolP_->ClearAll();
}

void
FramebufferSetupPool::ClearSetup(const std::string& setupName)
{
  map<std::string, pair<FramebufferSetup*, vector<string> > >::iterator it =
      fboSetupPool_.find(setupName);
  if (it != fboSetupPool_.end())
    {
      delete (it->second).first;
      fboSetupPool_.erase(it);
    }
}

void
FramebufferSetupPool::Activate(const std::string& setupName)
{
  map<std::string, pair<FramebufferSetup*, vector<string> > >::iterator it =
      fboSetupPool_.find(setupName);
  if (it != fboSetupPool_.end())
    {
      ((it->second).first)->Execute();
    }
}

///** Returns the pointer to a texture attached during a setup.
// * \attention it is not possible to read from and write into the same texture.
// **/
//glfTexture2D*
//FramebufferSetupPool::GetAttachment(const std::string& attachmentName)
//{
//  return (*texturePoolP_)[attachmentName];
//}

FramebufferSetup*
FramebufferSetupPool::GetSetup(const std::string& setupName)
{
  map<std::string, pair<FramebufferSetup*, vector<string> > >::iterator it =
      fboSetupPool_.find(setupName);
  if (it != fboSetupPool_.end())
    {
      return (it->second).first;
    }
  else
    {
        BIASWARN("A setup with this name : " << setupName << " does not exist");
      return NULL;
    }
}

glfFramebufferObject*
FramebufferSetupPool::GetFBO()
{
  return &fbo_;
}

Texture2DPool*
FramebufferSetupPool::GetTexturePool()
{
  return texturePoolP_;
}

glfTexture2D*
FramebufferSetupPool::GetAttachment(const string& setupName,
    const string& attachmentName)
{
  map<string, pair<FramebufferSetup*, vector<string> > >::iterator iter =
      fboSetupPool_.find(setupName);
  if (iter != fboSetupPool_.end())
    {
      vector<string>& attachmentNames = (iter->second).second;
      vector<string>::iterator name_iter = find(attachmentNames.begin(),
          attachmentNames.end(), attachmentName);
      if (name_iter != attachmentNames.end())
        {
          return (*texturePoolP_)[attachmentName];
        }
      else
        {
          return NULL;
        }
    }
  else
    {
      return NULL;
    }
}

void
FramebufferSetupPool::GetSetupAttachmentNames(const std::string& setupName,
    std::vector<std::string>& attachmentNames)
{
  map<string, pair<FramebufferSetup*, vector<string> > >::iterator iter =
      fboSetupPool_.find(setupName);
  if (iter != fboSetupPool_.end())
    {
      attachmentNames = (iter->second).second;

    }
  else {
    BIASWARN("no such setup : "<<setupName);
  }
}