glfVertexFormat.cpp

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

 Copyright (C)  2008, 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 "glfVertexFormat.hh"
#include "glfException.hh"

using namespace BIAS;

glfVertexFormat::glfVertexFormat()
{
  vertexSize_ = 0;
}

glfVertexFormat::~glfVertexFormat()
{
}

glfVertexFormat& glfVertexFormat::
operator=(const glfVertexFormat& v2) 
{
  vertexSize_ = v2.vertexSize_;
  for(unsigned int i=0; i<v2.attribDesc_.size(); i++) {
    attribDesc_.push_back(v2.attribDesc_[i]);
  }
  return *this;
}

void glfVertexFormat::AddAttribute(Attribute attrib, 
                                int index, GLenum type, 
                                int size, bool normalized)
{
  BIASASSERT(size > 0);
  BIASASSERT(index >= 0);
  BIASASSERT(attrib == ATTRIB_TEXCOORD || 
             attrib == ATTRIB_GENERIC || 
             index == 0);
  BIASASSERT(!HasAttribute(attrib, index));
  BIASASSERT(sizeof(GLubyte) == 1);

  // check if attribute is supported.
  std::string reason;
  if (!IsAttributeSupported(attrib, index, type, size, reason)) {
    GLF_THROW_EXCEPTION("Vertex attribute is not supported: " << reason);
  }

  // create attribute description.
  AttributeDesc desc;
  desc.attrib     = attrib;
  desc.index      = index;
  desc.offset     = vertexSize_;
  desc.type       = type;
  desc.size       = size;
  desc.normalized = normalized ? GL_TRUE : GL_FALSE;
  attribDesc_.push_back(desc);

  // update vertex size.
  int typeSize = 0;
  switch (type) {
  case GL_BYTE:           typeSize = sizeof(GLbyte); break;
  case GL_UNSIGNED_BYTE:  typeSize = sizeof(GLubyte); break;
  case GL_SHORT:          typeSize = sizeof(GLshort); break;
  case GL_UNSIGNED_SHORT: typeSize = sizeof(GLushort); break;
  case GL_INT:            typeSize = sizeof(GLint); break;
  case GL_UNSIGNED_INT:   typeSize = sizeof(GLuint); break;
  case GL_FLOAT:          typeSize = sizeof(GLfloat); break;
  case GL_DOUBLE:         typeSize = sizeof(GLdouble); break;
  }
  vertexSize_ += typeSize * size;
  BIASASSERT(vertexSize_ > 0);
}

int glfVertexFormat::GetVertexSize() const
{
  return vertexSize_;
}

bool glfVertexFormat::HasAttribute(Attribute attrib, int index) const
{
  BIASASSERT(attrib == ATTRIB_TEXCOORD || attrib == ATTRIB_GENERIC || index == 0);

  for (unsigned int i = 0; i < attribDesc_.size(); i++) {
    if (attribDesc_[i].attrib == attrib && attribDesc_[i].index == index) {
      return true;
    }
  }
  return false;
}

bool glfVertexFormat::GetAttributeInfo(Attribute attrib, int index, int& offset, GLenum& type, int& size) const
{
  BIASASSERT(attrib == ATTRIB_TEXCOORD || attrib == ATTRIB_GENERIC || index == 0);

  for (unsigned int i = 0; i < attribDesc_.size(); i++) {
    if (attribDesc_[i].attrib == attrib && attribDesc_[i].index == index) {
      offset = attribDesc_[i].offset;
      type   = attribDesc_[i].type;
      size   = attribDesc_[i].size;
      return true;
    }
  }
  return false;
}

bool glfVertexFormat::IsAttributeSupported(Attribute attrib, int index, GLenum type,
                                        int size, std::string& reason)
{
  switch (attrib) {

  case ATTRIB_POSITION:
    if (type != GL_SHORT &&
        type != GL_INT &&
        type != GL_FLOAT &&
        type != GL_DOUBLE) {
      reason = "Type of ATTRIBUTE_POSITION must be GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE.";
      return false;
    }
    if (size < 2 || size > 4) {
      reason = "Size of ATTRIBUTE_POSITION must be 2, 3, or 4.";
      return false;
    }
    break;

  case ATTRIB_NORMAL:
    if (type != GL_BYTE &&
        type != GL_SHORT &&
        type != GL_INT &&
        type != GL_FLOAT &&
        type != GL_DOUBLE) {
      reason = "Type of ATTRIBUTE_NORMAL must be GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE.";
      return false;
    }
    if (size != 3) {
      reason = "Size of ATTRIBUTE_NORMAL must be 3.";
      return false;
    }
    break;

  case ATTRIB_COLOR:
    if (type != GL_BYTE &&
        type != GL_UNSIGNED_BYTE &&
        type != GL_SHORT &&
        type != GL_UNSIGNED_SHORT &&
        type != GL_INT &&
        type != GL_UNSIGNED_INT &&
        type != GL_FLOAT &&
        type != GL_DOUBLE) {
      reason = "Type of ATTRIBUTE_COLOR must be GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, "
               "GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE.";
      return false;
    }
    if (size < 3 || size > 4) {
      reason = "Size of ATTRIBUTE_COLOR must be 3 or 4.";
      return false;
    }
    break;

  case ATTRIB_TEXCOORD:
    if (type != GL_SHORT &&
        type != GL_INT &&
        type != GL_FLOAT &&
        type != GL_DOUBLE) {
      reason = "Type of ATTRIBUTE_TEXCOORD must be GL_SHORT, GL_INT, GL_FLOAT, or GL_DOUBLE";
      return false;
    }
    if (size < 1 || size > 4) {
      reason = "Size of ATTRIBUTE_TEXCOORD must be 1, 2, 3, or 4.";
      return false;
    }
    GLint maxTextureCoords;
    glGetIntegerv(GL_MAX_TEXTURE_COORDS, &maxTextureCoords);
    if (index >= maxTextureCoords) {
      std::stringstream s;
      s << "Index of ATTRIBUTE_TEXCOORD must be < " << maxTextureCoords;
      reason = s.str();
      return false;
    }
    break;

  case ATTRIB_GENERIC:
    if (type != GL_BYTE &&
        type != GL_UNSIGNED_BYTE &&
        type != GL_SHORT &&
        type != GL_UNSIGNED_SHORT &&
        type != GL_INT &&
        type != GL_UNSIGNED_INT &&
        type != GL_FLOAT &&
        type != GL_DOUBLE) {
      reason = "Type of ATTRIBUTE_GENERIC must be GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, "
               "GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT, or GL_DOUBLE.";
      return false;
    }
    if (size < 1 || size > 4) {
      reason = "Size of ATTRIBUTE_GENERIC must be 1, 2, 3, or 4.";
      return false;
    }
    GLint maxVertexAttribs;
    glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
    if (index >= maxVertexAttribs) {
      std::stringstream s;
      s << "Index of ATTRIBUTE_GENERIC must be < " << maxVertexAttribs;
      reason = s.str();
      return false;
    }
    break;

  default:
    reason = "Invalid vertex attribute.";
    return false;
    break;

  }

  return true;
}

void glfVertexFormat::Bind(const void* data) const
{
  GLint maxTextureCoords;
  glGetIntegerv(GL_MAX_TEXTURE_COORDS, &maxTextureCoords);
  GLint maxVertexAttribs;
  glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);

  // first disable all attribute arrays, because it is unknown which are enabled now.
  glDisableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_NORMAL_ARRAY);
  glDisableClientState(GL_COLOR_ARRAY);
  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);
  }
  
  for (unsigned int i = 0; i < attribDesc_.size(); i++) {
    const AttributeDesc& desc = attribDesc_[i];
    switch (desc.attrib) {
    case ATTRIB_POSITION:
      glEnableClientState(GL_VERTEX_ARRAY);
      glVertexPointer(desc.size, desc.type, vertexSize_, (GLubyte*)data + desc.offset);
      break;
    case ATTRIB_NORMAL:
      glEnableClientState(GL_NORMAL_ARRAY);
      glNormalPointer(desc.type, vertexSize_, (GLubyte*)data + desc.offset);
      break;
    case ATTRIB_COLOR:
      glEnableClientState(GL_COLOR_ARRAY);
      glColorPointer(desc.size, desc.type, vertexSize_, (GLubyte*)data + desc.offset);
      break;
    case ATTRIB_TEXCOORD:
      glClientActiveTexture(GL_TEXTURE0 + desc.index);
      glEnableClientState(GL_TEXTURE_COORD_ARRAY);
      glTexCoordPointer(desc.size, desc.type, vertexSize_, (GLubyte*)data + desc.offset);
      break;
    case ATTRIB_GENERIC:
      glEnableVertexAttribArray(desc.index);
      glVertexAttribPointer(desc.index, desc.size, desc.type, desc.normalized,
                            vertexSize_, (GLubyte*)data + desc.offset);
      break;
    }
  }

  GLF_THROW_ON_OPENGL_ERROR;
}