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

using namespace BIAS;

glfVertexBuffer::glfVertexBuffer()
{
  useBuffer_ = false;
  numVertices_ = 0;
  bufferID_ = 0;
  mapped_ = false;
  array_ = NULL;
}

glfVertexBuffer::~glfVertexBuffer()
{
  if (bufferID_ != 0) {
    glDeleteBuffers(1, &bufferID_);
  }
  delete [] array_;
}


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


void glfVertexBuffer::Create(int numVertices,
                             const glfVertexFormat& format,
                             const void* data,
                          bool useBuffer)
{
  BIASASSERT(!mapped_);

  format_ = format;
  numVertices_ = numVertices;

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

  if (useBuffer_) {

    // upload to OpenGL buffer
    if (bufferID_ == 0) {
      glGenBuffers(1, &bufferID_);
    }
    glBindBuffer(GL_ARRAY_BUFFER, bufferID_);
    glBufferData(GL_ARRAY_BUFFER,
                 numVertices * format.GetVertexSize(),
                 data, GL_STATIC_DRAW);
  } else {

    // create a copy of data in system memory
    //    array_.resize(numVertices * format.GetVertexSize());
    delete[] array_;
    array_ = new GLubyte[numVertices * format.GetVertexSize()];
    memcpy(array_, data, numVertices * format.GetVertexSize());
  }

  GLF_THROW_ON_OPENGL_ERROR;
}

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

  if (useBuffer_) {
    BIASASSERT(bufferID_ != 0);
    glBindBuffer(GL_ARRAY_BUFFER, bufferID_);
    return glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
  } else {
    return array_;
  }
}

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

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

int glfVertexBuffer::GetNumVertices() const
{
  return numVertices_;
}

void glfVertexBuffer::Bind() const
{
  if (useBuffer_) {
    BIASASSERT(bufferID_ != 0);
    glBindBuffer(GL_ARRAY_BUFFER, bufferID_);
    format_.Bind(NULL);
  } else {
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    format_.Bind(array_);
  }
}