glfBatch.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 "glfBatch.hh"
#include "glfScreen.hh"
#include "glfException.hh"

using namespace BIAS;

const GLenum INVALID_PRIMITIVE_TYPE = 0xffffffff;

glfBatch::glfBatch() :
  MAX_TEXTURE_UNITS_(-1),
  MAX_TEXTURE_COORDS_(-1),
  initialized_(false),
  maxUsedTextureIndex_(-1),
  maxUsedTextureMatrixIndex_(-1)
{
  viewport_ = NULL;
  depthBufferMode_ = &glfDepthBufferMode::DEFAULT;
  stencilBufferMode_ = &glfStencilBufferMode::DEFAULT;
  blendMode_ = &glfBlendMode::DEFAULT;
  shaderProgram_ = NULL;
  renderTarget_ = &glfScreen::GetInstance();
  vertexBuffer_ = NULL;
  elementBuffer_ = NULL;
  primitiveType_ = INVALID_PRIMITIVE_TYPE;
  first_ = 0;
  count_ = -1;
  modelViewMatrix_ = &glfMatrix::IDENTITY;
  projectionMatrix_ = &glfMatrix::IDENTITY;
}

glfBatch::~glfBatch()
{
}

void glfBatch::SetRenderTarget(const glfRenderTarget* renderTarget)
{
  BIASASSERT(renderTarget != NULL);
  renderTarget_ = renderTarget;
}

void glfBatch::SetViewport(const glfViewport* viewport)
{
  BIASASSERT(viewport != NULL);
  viewport_ = viewport;
}

void glfBatch::SetTexture(const glfTexture* texture, int textureUnit)
{
  //BIASASSERT(textureUnit >= 0 && textureUnit < MAX_TEXTURE_UNITS);
  if(initialized_) {
    BIASASSERT(textureUnit >= 0 && textureUnit < MAX_TEXTURE_UNITS_);
  }
  if((int)textures_.size() <= textureUnit) {
    textures_.resize(textureUnit+1, NULL);
  }
  if(maxUsedTextureIndex_<textureUnit && texture!= NULL)
    maxUsedTextureIndex_=textureUnit;

  if(textureUnit == maxUsedTextureIndex_-1 && texture == NULL) {
    maxUsedTextureIndex_--;
  }

  textures_[textureUnit] = texture;
}

void glfBatch::ReleaseTextures(unsigned int fromIndex)
{
  for(int i=maxUsedTextureIndex_;
    i>=static_cast<int>(fromIndex); i--){
    SetTexture(NULL, i);
  }
  maxUsedTextureIndex_ = fromIndex-1;
}


unsigned int glfBatch::GetMaxUsedTextureIndex()
{
  return maxUsedTextureIndex_;
}


void glfBatch::SetDepthBufferMode(const glfDepthBufferMode* depthBufferMode)
{
  BIASASSERT(depthBufferMode != NULL);
  depthBufferMode_ = depthBufferMode;
}

void glfBatch::SetStencilBufferMode(const glfStencilBufferMode* stencilBufferMode)
{
  BIASASSERT(stencilBufferMode != NULL);
  stencilBufferMode_ = stencilBufferMode;
}

void glfBatch::SetBlendMode(const glfBlendMode* blendMode)
{
  BIASASSERT(blendMode != NULL);
  blendMode_ = blendMode;
}

void glfBatch::SetShaderProgram(const glfShaderProgram* shaderProgram)
{
  shaderProgram_ = shaderProgram;
}

void glfBatch::SetVertexBuffer(const glfVertexBuffer* vertexBuffer)
{
  vertexBuffer_ = vertexBuffer;
}

void glfBatch::SetElementBuffer(const glfElementBuffer* elementBuffer)
{
  elementBuffer_ = elementBuffer;
}

void glfBatch::SetPrimitiveType(GLenum primitiveType)
{
  primitiveType_ = primitiveType;
}

void glfBatch::SetRange(int first, int count)
{
  first_ = first;
  count_ = count;
}

void glfBatch::SetModelViewMatrix(const glfMatrix* matrix)
{
  BIASASSERT(matrix != NULL);
  modelViewMatrix_ = matrix;
}

void glfBatch::SetProjectionMatrix(const glfMatrix* matrix)
{
  BIASASSERT(matrix != NULL);
  projectionMatrix_ = matrix;
}

void glfBatch::SetTextureMatrix(const glfMatrix* matrix, int index)
{
  if(initialized_) {
     BIASASSERT(index >= 0 && index < MAX_TEXTURE_COORDS_);
  } else {
    if((int)textureMatrix_.size() <= index) {
      textureMatrix_.resize(index+1, NULL);
    }
  }

  if(maxUsedTextureMatrixIndex_<index && matrix != NULL)
    maxUsedTextureMatrixIndex_=index;

  textureMatrix_[index] = matrix;

  if(index == maxUsedTextureMatrixIndex_-1 && matrix == NULL) {
    maxUsedTextureMatrixIndex_--;
  }
}

void glfBatch::ReleaseTextureMatrices(unsigned int fromIndex)
{
  for(int i=maxUsedTextureMatrixIndex_;
    i>=static_cast<int>(fromIndex); i--){

    SetTextureMatrix(NULL, i);
  }
  maxUsedTextureMatrixIndex_ = fromIndex-1;

}

unsigned int glfBatch::GetMaxUsedTextureMatrixIndex() const
{
  return maxUsedTextureMatrixIndex_;
}

void glfBatch::Init()
{
    //std::cout<<"Batch init:"<<std::endl;
  MAX_TEXTURE_UNITS_ = GetMaxSupportedTextureUnits();
  MAX_TEXTURE_COORDS_ = GetMaxSupportedTextureMatrices();

  if(static_cast<int>(textureMatrix_.size())>MAX_TEXTURE_COORDS_)
    GLF_THROW_EXCEPTION("Too many texture matrices assigned!");
  if(static_cast<int>(textures_.size())>MAX_TEXTURE_UNITS_)
    GLF_THROW_EXCEPTION("Too many textures assigned!");

  if(static_cast<int>(textureMatrix_.size())<MAX_TEXTURE_COORDS_) {
    textureMatrix_.resize(MAX_TEXTURE_COORDS_, NULL);
  }
  if(static_cast<int>(textures_.size())<MAX_TEXTURE_UNITS_) {
    textures_.resize(MAX_TEXTURE_UNITS_, NULL);
  }
  initialized_ = true;
}

void glfBatch::Draw()
{
  BindRenderStates();

  if (elementBuffer_ != NULL) {
    // draw from element buffer
    elementBuffer_->Draw(first_, count_);
  } else {
    // draw straight from vertex buffer
    int count = count_;
    if (count == -1) {
      count = vertexBuffer_->GetNumVertices();
    }
    BIASASSERT(primitiveType_ != INVALID_PRIMITIVE_TYPE);
    glDrawArrays(primitiveType_, first_, count);
  }

  glFinish();

  GLF_THROW_ON_OPENGL_ERROR;
}


void glfBatch::BindRenderStates()
{
  if(!initialized_) {
    Init();
  }

  // bind render target
  if(renderTarget_ != NULL)
    renderTarget_->Bind();

  // bind viewport
  if(viewport_ != NULL)
    viewport_->Bind();

  // bind textures
  for (int i = 0; i <= maxUsedTextureIndex_; i++) {
    if (textures_[i] != NULL) {
      glActiveTexture(GL_TEXTURE0 + i);
      textures_[i]->Bind();
    }
  }

  // bind depth buffer mode
  if(depthBufferMode_ != NULL)
    depthBufferMode_->Bind();

  if(stencilBufferMode_ != NULL)
    stencilBufferMode_->Bind();

  // bind blend mode
  if(blendMode_ != NULL)
    blendMode_->Bind();

  // bind shader program
  if (shaderProgram_ != NULL) {
    shaderProgram_->Bind();
  } else {
    /** Is this code incomplete ?? **/
    glUseProgram(0); // use fixed-function pipeline
    if (textures_[0] != NULL) {
      glActiveTexture(GL_TEXTURE0);
      glEnable(textures_[0]->GetTextureTarget());
    } else {
      glActiveTexture(GL_TEXTURE0);
      glDisable(GL_TEXTURE_1D);
      glDisable(GL_TEXTURE_2D);
      glDisable(GL_TEXTURE_3D);
    }
  }

  // bind vertex buffer
  if(vertexBuffer_ != NULL)
    vertexBuffer_->Bind();

  // load modelview matrix
  if (modelViewMatrix_ != NULL) {
    glMatrixMode(GL_MODELVIEW);
    modelViewMatrix_->Load();
  }

  // load projection matrix
  if (projectionMatrix_ != NULL) {
    glMatrixMode(GL_PROJECTION);
    projectionMatrix_->Load();
  }

  // load texture matrices
 // for (int i = 0; i <= maxUsedTextureMatrixIndex_; i++) {
  for (int i = 0; i < MAX_TEXTURE_COORDS_; i++) {
    if (textureMatrix_[i] != NULL) {
      glActiveTexture(GL_TEXTURE0 + i);
      glMatrixMode(GL_TEXTURE);
      textureMatrix_[i]->Load();
    } else {
      //why should I want to do this ? -> fixed function ?
      glActiveTexture(GL_TEXTURE0 + i);
      glMatrixMode(GL_TEXTURE);
      glLoadIdentity();
    }
  }
}

int glfBatch::GetMaxSupportedTextureUnits()
{
  GLint TUs = 0;
  glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &TUs);\
  return static_cast<int>(TUs);
}

int glfBatch::GetMaxSupportedTextureMatrices()
{
  GLint matrices = 0;
  glGetIntegerv(GL_MAX_TEXTURE_COORDS, &matrices);
  return static_cast<int>(matrices);
}

void glfBatch::SetDefaultRenderStates()
{
  int MAX_TEXTURE_UNITS = GetMaxSupportedTextureUnits();
  int MAX_TEXTURE_COORDS = GetMaxSupportedTextureMatrices();

  // reset render target
  glfScreen::GetInstance().Bind();
  GLF_THROW_ON_OPENGL_ERROR

  // reset textures
  for (int i = 0; i < MAX_TEXTURE_UNITS; i++) {
    glActiveTexture(GL_TEXTURE0 + i);
    glBindTexture(GL_TEXTURE_1D, 0);
    glBindTexture(GL_TEXTURE_2D, 0);
    glBindTexture(GL_TEXTURE_3D, 0);
  }

  // reset depth buffer mode
  glfDepthBufferMode::DEFAULT.Bind();

  // reset blend mode
  glfBlendMode::DEFAULT.Bind();

  //reset stencil
  glfStencilBufferMode::DEFAULT.Bind();

  // reset shader program
  glUseProgram(0);

  // reset vertex buffer
  glBindBuffer(GL_ARRAY_BUFFER, 0);
  GLint maxTextureCoords;
  glGetIntegerv(GL_MAX_TEXTURE_COORDS, &maxTextureCoords);
  GLint maxVertexAttribs;
  glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
  glDisableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_NORMAL_ARRAY);
  glDisableClientState(GL_COLOR_ARRAY);

  /// todo: this loop made problems with open scene graph for SIGGRAPH09, fkellner
  //  for (int i = 0; i < maxTextureCoords; i++) {
  //    glClientActiveTexture(GL_TEXTURE0 + i);
  //    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  //  }
  for (int i = 0; i < maxVertexAttribs; i++) {
    glDisableVertexAttribArray(i);
  }

  // reset modelview matrix
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  // reset projection matrix
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  // reset texture matrices
  for (int i = 0; i < MAX_TEXTURE_COORDS; i++) {
    glActiveTexture(GL_TEXTURE0 + i);
    glMatrixMode(GL_TEXTURE);
    glLoadIdentity();
  }

  // reset active texture
  glActiveTexture(GL_TEXTURE0);

  // reset element buffer
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  GLF_THROW_ON_OPENGL_ERROR
}