PlainPerPixelProcessing.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/SpecializedBatches/PlainPerPixelProcessing.hh>
#include <OpenGLFramework/Utils/Primitives.hh>
#include <OpenGLFramework/Base/glfUniformNotFoundException.hh>

using namespace BIAS;
using namespace std;

PlainPerPixelProcessing::
PlainPerPixelProcessing(bool flip) : 
basicInit_(false), initialized_(false), numInputTextures_(0),
flipTexCoord_(flip), //usePingPongTextures_(false), isPing_(true),
externalUniformsChanged_(false)
{}

void PlainPerPixelProcessing::
ReleaseTextures(){
  batch_.ReleaseTextures(0);
}

void PlainPerPixelProcessing::
SetTexture(BIAS::glfTexture2D* inputTexture)
{
  batch_.SetTexture(inputTexture, 0);
  if( numInputTextures_ != 1 ) {
    initialized_ = false;
    numInputTextures_ = 1;
  }
}

void 
PlainPerPixelProcessing::SetSamplerNames(const std::vector<std::string>& samplerNames)
{
  samplerNames_ = samplerNames;
  initialized_ = false;
}

void PlainPerPixelProcessing::
SetTextures(const std::vector<BIAS::glfTexture2D*>& inputTextures)
{
  for(unsigned int i=0; i<inputTextures.size(); i++)
    batch_.SetTexture(inputTextures[i], i);
  if( numInputTextures_ != inputTextures.size() ) {
    initialized_ = false;
    numInputTextures_ = inputTextures.size();
  }
}

void PlainPerPixelProcessing::
SetTextures(std::list<BIAS::glfTexture2D*>& inputTextures)
{
  std::list<BIAS::glfTexture2D*>::iterator it = inputTextures.begin();
  std::list<BIAS::glfTexture2D*>::iterator itEnd = inputTextures.end();
  unsigned int i=0;
  for( ;it!=itEnd; it++ ) {
    batch_.SetTexture((*it), i++);
  }
  if( numInputTextures_ != inputTextures.size() ) {
    initialized_ = false;
    numInputTextures_ = inputTextures.size();
  }
}


void PlainPerPixelProcessing::
SetOutputSize(unsigned int width, unsigned int height)
{
  viewport_.SetSize(static_cast<int>(width), 
                    static_cast<int>(height));
  initialized_ = false;
}

void PlainPerPixelProcessing::
SetRenderTarget(BIAS::glfRenderTarget* rt)
{
  batch_.SetRenderTarget(rt);
}

void PlainPerPixelProcessing::
SetFragmentShaderFromFile(const std::string& fileName)
{
  fragmentShader_.CreateFromFile(GL_FRAGMENT_SHADER, fileName);    
  initialized_ = false;
}

void 
PlainPerPixelProcessing::SetFragmentShaderFromString(const std::string& source)
{
  fragmentShader_.Create(GL_FRAGMENT_SHADER, source);
  initialized_ = false;
}

void PlainPerPixelProcessing::
Execute()
{
  if(!initialized_) {
    Init_();
  }
  if(externalUniformsChanged_) {
    for(std::map<std::string, float>::iterator it = uniformsFloat_.begin(); 
      it!=uniformsFloat_.end(); it++) {
        shaderProgram_.SetUniform(it->first, it->second);
    }
    for(std::map<std::string, int>::iterator it = uniformsInt_.begin(); 
        it!=uniformsInt_.end(); it++) {
      shaderProgram_.SetUniform(it->first, it->second);
    }
    externalUniformsChanged_ = false;
  }
  batch_.Draw();
}

void 
PlainPerPixelProcessing::SetFlip(bool flip) 
{
  flipTexCoord_ = flip;
  basicInit_ = false;
}

void PlainPerPixelProcessing::
Init_()
{
  if(!basicInit_) {
    InitBatch_();
    InitPrimitiveData_();
    InitVertexTransformation_();
    //    InitPerFragmentOperations_();
    InitShaders_();
    basicInit_=true;    
  }

  
  shaderProgram_.Link();
   externalUniformsChanged_ = true;

  Vector<float> pixelOffset(2);
  pixelOffset[0] = 1.0f/static_cast<float>(viewport_.GetWidth());
  pixelOffset[1] = 1.0f/static_cast<float>(viewport_.GetHeight());
  try {
    shaderProgram_.SetUniform("MIP_pixelOffset", pixelOffset);
  } catch(glfUniformNotFoundException& e) {
    if(!e.NotFoundUniform("MIP_pixelOffset")) {
      throw e;
    }
  }

  for(int i=0; i<static_cast<int>(numInputTextures_); i++) {

    if(i>=static_cast<int>(samplerNames_.size())) {
      stringstream sstr;
      sstr<<"img"<<i;
      shaderProgram_.SetUniform(sstr.str(), i);
    } else {
      shaderProgram_.SetUniform(samplerNames_[i], i);
    }
  }
}

// void 
// PlainPerPixelProcessing::SetPingPongTextures(const std::vector<BIAS::glfTexture2D*>& ping,
//                                              const std::vector<BIAS::glfTexture2D*>& pong,
//                                              const PlainPerPixelProcessing::PingPongID& activeID)
// {
  
//   PingPongTex_[PlainPerPixelProcessing::ping] = ping;
//   PingPongTex_[PlainPerPixelProcessing::pong] = pong;

//   usePingPongTextures_ = true;
//   SetTextures(PingPongTex_[activeID]);
//   isPing_ = (activeID==PlainPerPixelProcessing::ping);
// }

// void 
// PlainPerPixelProcessing::SetPingPongTextures(const std::vector<BIAS::glfTexture2D*>& ping,
//                                              const std::vector<BIAS::glfTexture2D*>& pong,
//                                              const std::vector<BIAS::glfTexture2D*>& unSwapped,
//                                              const PlainPerPixelProcessing::PingPongID& activeID)
// {
  
//   PingPongTex_[PlainPerPixelProcessing::ping] = ping;
//   PingPongTex_[PlainPerPixelProcessing::ping].insert(PingPongTex_[PlainPerPixelProcessing::ping].end(),
//                                                      unSwapped.begin(), unSwapped.end());
//   PingPongTex_[PlainPerPixelProcessing::pong] = pong;
//   PingPongTex_[PlainPerPixelProcessing::pong].insert(PingPongTex_[PlainPerPixelProcessing::pong].end(),
//                                                      unSwapped.begin(), unSwapped.end());


//   usePingPongTextures_ = true;
//   SetTextures(PingPongTex_[activeID]);
//   isPing_ = (activeID==PlainPerPixelProcessing::ping);
// }

// void 
// PlainPerPixelProcessing::SetPingPongTextures(const std::vector<BIAS::glfTexture2D*>& ping,
//                                              const std::vector<BIAS::glfTexture2D*>& pong,
//                                              BIAS::glfTexture2D* unSwapped,
//                                              const PlainPerPixelProcessing::PingPongID& activeID)
// {
  
//   PingPongTex_[PlainPerPixelProcessing::ping] = ping;
//   PingPongTex_[PlainPerPixelProcessing::ping].insert(PingPongTex_[PlainPerPixelProcessing::ping].end(),
//                                                      unSwapped);
//   PingPongTex_[PlainPerPixelProcessing::pong] = pong;
//   PingPongTex_[PlainPerPixelProcessing::pong].insert(PingPongTex_[PlainPerPixelProcessing::pong].end(),
//                                                      unSwapped);


//   usePingPongTextures_ = true;
//   SetTextures(PingPongTex_[activeID]);
//   isPing_ = (activeID==PlainPerPixelProcessing::ping);
// }
 
// PlainPerPixelProcessing::PingPongID
// PlainPerPixelProcessing::SwapPingPongTextures()
// {
//   BIASASSERT(usePingPongTextures_);
//   isPing_ = !isPing_;
//   if(isPing_) {
//     SetTextures(PingPongTex_[PlainPerPixelProcessing::ping]);
//     return PlainPerPixelProcessing::ping;
//   }  else {
//     SetTextures(PingPongTex_[PlainPerPixelProcessing::pong]);
//     return PlainPerPixelProcessing::pong;
//   }
// }

// PlainPerPixelProcessing::PingPongID
// PlainPerPixelProcessing::GetCurrentPingPongID() const
// {
//   if(isPing_) {
//     return PlainPerPixelProcessing::ping;
//   }  else {
//     return PlainPerPixelProcessing::pong;
//   }
// }

void PlainPerPixelProcessing::
InitBatch_() 
{
  batch_.SetDepthBufferMode(&depthTest_);
  batch_.SetElementBuffer(&elements_);
  batch_.SetVertexBuffer(&vertices_);
  batch_.SetViewport(&viewport_);
  batch_.SetModelViewMatrix(&ModelViewMatrix_);
  batch_.SetProjectionMatrix(&ProjectionMatrix_);
  batch_.SetShaderProgram(&shaderProgram_);
}

void PlainPerPixelProcessing::
InitVertexTransformation_()
{
  ModelViewMatrix_.MakeIdentity();
  ProjectionMatrix_.MakeIdentity();
}

void PlainPerPixelProcessing::
InitPrimitiveData_()
{
  Primitives::PlainQuad2DWithTexture2D(vertices_, elements_, flipTexCoord_);
}

// void PlainPerPixelProcessing::
// InitPerFragmentOperations_()
// {
//   //  depthTest_.SetDepthTest(false);
// }

void PlainPerPixelProcessing::
InitShaders_()
{
  shaderProgram_.Create();
  shaderProgram_.AttachShader(fragmentShader_);
}

//void 
//PlainPerPixelProcessing::Link()
//{
//  Init_();
//}
//
//glfShaderProgram* 
//PlainPerPixelProcessing::GetProgram()
//{
//  return &shaderProgram_;
//}

void 
PlainPerPixelProcessing::SetUniform(const std::string& name, float val)
{
  uniformsFloat_[name] = val;
  externalUniformsChanged_ = true;
}

void 
PlainPerPixelProcessing::SetUniform(const std::string& name, int val)
{
  uniformsInt_[name] = val;
  externalUniformsChanged_ = true;
}


glfDepthBufferMode& 
PlainPerPixelProcessing::GetDepthBufferMode()
{
  return depthTest_;
}