TemplateSpecializedBatch.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/TemplateSpecializedBatch.hh>
#include <OpenGLFramework/Utils/Primitives.hh>

using namespace BIAS;
using namespace std;

TemplateSpecializedBatch::
TemplateSpecializedBatch() : 
processingScheme_(myProcessingScheme),
initialized_(false),
callPreExecuteFlag_(true)
{}


void TemplateSpecializedBatch::
Init(TemplateSpecializedBatch::ProcessingScheme ps)
{
  if(initialized_) {
    BIASWARN("[TemplateSpecializedBatch] : Aready initilized!");
    return;
  }
  processingScheme_ = ps;

  /** Remove unneccesary lines **/
  InitPrimitiveData_();
  InitTextureData_();
  InitTextureMatrixData_();
  InitVertexTransformation_();
  InitShaders_();
  InitPerFragmentOperations_();


  InitBatch_();
  initialized_ = true;
}

void TemplateSpecializedBatch::
InitPrimitiveData_()
{
  //as an example a simple quad is appended
  Primitives::PlainQuad2DWithTexture2D(vertices_, elements_);
}

void TemplateSpecializedBatch::
InitTextureData_()
{
  textureInTextureUnit0.Create();
  textureInTextureUnit0.Set();
}

void TemplateSpecializedBatch::
InitTextureMatrixData_()
{
  //in this example nothing is done here 
}

void TemplateSpecializedBatch::
InitVertexTransformation_()
{
  //If the projection and modelview matrix are identity matrices,
  //the geometry specified in Primitives::PlainQuad2DWithTexture2D
  // (see InitPrimitiveData_())
  //will be mapped in a way, that it completely fills the viewport 
  //(see OpenGL Specs. for more info).
  //This is what we typically want when processing an 
  //complete image. So we are fine with the identities matrices!
  
  ModelViewMatrix_.MakeIdentity();
  ProjectionMatrix_.MakeIdentity();

  //we leave the viewport out here because its 
  //manipulated by SetViewport method.

}

void TemplateSpecializedBatch::
InitShaders_()
{
  shaderProgram_.Create();
  
  string fragmentProgram =
    "uniform sampler2D image;" //input image
    ""
    "void main() {"
    " vec4 color = texture2D(image, gl_TexCoord[0]);"
    //permutate colors of texture and output to the framebuffer
    " gl_FragColor.r = color.g;"
    " gl_FragColor.g = color.b;"
    " gl_FragColor.b = color.r;"
    " gl_FragColor.a = color.a;"
    "}";
    fragmentShader_.Create(GL_FRAGMENT_SHADER, fragmentProgram);
  //fragmentShader_.Create(GL_FRAGMENT_SHADER); 
  //  is an alternative, which can be used to get an object id
  //  without specifying the code.

  shaderProgram_.AttachShader(fragmentShader_);
  shaderProgram_.Link();
  //this associates texture unit 0 to be connected with the name 
  // "image" in the shader program.
  // The texture bound to this unit is required to be a 2D texture.
  // (see shader program above).
  // SetUniform is the method to set uniforms, which are also
  // ints, floats, vectors and matrices!
  shaderProgram_.SetUniform("image", 0); 
}


void TemplateSpecializedBatch::
SetViewport(unsigned int viewportWidth, 
      unsigned int viewportHeight, 
      unsigned int viewportOx, 
      unsigned int viewportOy)
{
  viewport_.SetOrigin(viewportOx, viewportOy);
  viewport_.SetSize(viewportWidth, viewportHeight);
}

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

void TemplateSpecializedBatch::
InitPerFragmentOperations_()
{
  //don't need this in this example
  depthTest_.SetDepthTest(true);
}

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

  batch_.SetTexture(&textureInTextureUnit0, 0);
}

void TemplateSpecializedBatch::
Execute() {

  BIASASSERT(initialized_);

  if(callPreExecuteFlag_) {
    PreExecute_();
  }

  batch_.Draw();

}

void TemplateSpecializedBatch::
PreExecute_(){
  //update some GL state based internal state
  // our simple example doesn't use this ... could as well be
  //removed
  BIASWARN("this implementation still contains example-code!");
}

void TemplateSpecializedBatch::
Update() {
  //use this method to rearange state information which
  // will stay fixed over several executions or to 
  //synchronsize changes that need multiple communication calls.
}

void TemplateSpecializedBatch::
UploadTextureImage(BIAS::ImageBase& img)
{
  textureInTextureUnit0.UploadImage(img);
}