glfElementBuffer.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 <cstring>
#include "glfElementBuffer.hh"
#include "glfException.hh"

using namespace BIAS;

glfElementBuffer::glfElementBuffer()
{
  numIndices_ = 0;
  typeSize_ = 0;
  useBuffer_ = false;
  bufferID_ = 0;
  mapped_ = false;
}

glfElementBuffer::~glfElementBuffer()
{
  if (bufferID_ != 0) {
    glDeleteBuffers(1, &bufferID_);
  }
}


glfElementBuffer& 
glfElementBuffer::operator=(const glfElementBuffer& b)
{
  return (*this);
}
    
glfElementBuffer::glfElementBuffer(const glfElementBuffer& b)
{}

void glfElementBuffer::
Create(int numIndices,
       GLenum type,
       GLenum mode, const void* indices)
{
  BIASASSERT(!mapped_);

  mode_ = mode;
  type_ = type;
  numIndices_ = numIndices;

  switch (type) {
  case GL_UNSIGNED_BYTE:
    typeSize_ = sizeof(GLubyte);
    break;
  case GL_UNSIGNED_SHORT:
    typeSize_ = sizeof(GLushort);
    break;
  case GL_UNSIGNED_INT:
    typeSize_ = sizeof(GLuint);
    break;
  }

  // check whether to use OpenGL buffers.
  useBuffer_ = false;
#ifdef BIAS_HAVE_GLEW
  if (GLEW_VERSION_1_5) {
    useBuffer_ = true;
  }
#endif

  if (useBuffer_) {

    // upload to OpenGL buffer
    if (bufferID_ == 0) {
      glGenBuffers(1, &bufferID_);
    }
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferID_);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, numIndices * typeSize_,
                 indices, GL_STATIC_DRAW);

  } else {

    // create a copy of data in system memory
    array_.resize(numIndices * typeSize_);
    memcpy(&array_[0], indices, numIndices * typeSize_);

  }

  GLF_THROW_ON_OPENGL_ERROR;
}

void* glfElementBuffer::Map()
{
  BIASASSERT(!mapped_);
  mapped_ = true;

  if (useBuffer_) {
    BIASASSERT(bufferID_ != 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferID_);
    return glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
  } else {
    return &array_[0];
  }
}

void glfElementBuffer::Unmap()
{
  BIASASSERT(mapped_);
  mapped_ = false;

  if (useBuffer_) {
    BIASASSERT(bufferID_ != 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferID_);
    GLboolean result = glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
    if (result == GL_FALSE) {
      GLF_THROW_EXCEPTION("Element buffer was corrupted while mapped");
    }
  }
}

void glfElementBuffer::Draw(int first, int count) const
{
  BIASASSERT(!mapped_);
  BIASASSERT(first >= 0 && first < numIndices_);
  BIASASSERT(count == -1 || (count >= 0 && (first+count) <= numIndices_));

  if (count == -1) {
    count = numIndices_;
    first = 0;
  }

  const void* indices = NULL;
  if (useBuffer_) {
    BIASASSERT(bufferID_ != 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferID_);
  } else {
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    indices = &array_[0];
  }

  indices = (GLubyte*)indices + (first*typeSize_);

  glDrawElements(mode_, count, type_, indices);

  GLF_THROW_ON_OPENGL_ERROR;
}