rtcMeshSet3DVBONode.cpp

Go to the documentation of this file.

/*
* Copyright (C) 2008
* Robert Bosch LLC
* Research and Technology Center North America
* Palo Alto, California
*
* All rights reserved.
*
*------------------------------------------------------------------------------
* project ....: PUMA: Probablistic Unsupervised Model Acquisition
* file .......: MeshSet3DVBONode.cpp
* authors ....: Zhexi Wang
* organization: Robert Bosch LLC
* creation ...: 02/04/2009
* modified ...: $Date: 2009-02-02 12:17:10 -0800 (Mon, 02 Feb 2009) $
* changed by .: $Author: wg75pal $
* revision ...: $Revision: 772 $
*/
#include <GL/glew.h>
#include "rtc/rtcMeshSet3DVBONode.h"

#define VBO_NORMAL 0x01
#define VBO_COLOR 0x02
#define VBO_TEXCOORD 0x04
#define VBO_TEXTURE 0x08

#define CHECKGL while(true){int err=glGetError();if (err==0) break;else printf("OpenGL ERROR: %d, at %s, line %d\n",err,__FILE__,__LINE__);}

namespace rtc {
MeshSet3DVBONode::MeshSet3DVBONode(Renderer* renderer, MeshSet3D* meshset)
:RenderNode(renderer)
{
  num_mesh=meshset->numMeshes();
  meshvbos=new MeshVBO[num_mesh];
  memset(meshvbos,0,sizeof(MeshVBO)*num_mesh);
  for (int m=0;m<num_mesh;m++)
  {
    Mesh3D *mesh=meshset->meshes[m];
    MeshVBO *vbo=meshvbos+m;
    vbo->num_vertices = mesh->vertices.size();
    vbo->num_faces = mesh->faces.size();

    vbo->position_size = vbo->num_vertices * 3;
    vbo->position_data = new GLfloat[vbo->position_size];

    vbo->index_size = vbo->num_faces * 3;
    vbo->index_data = new GLuint[vbo->index_size];

    vbo->normal_size = vbo->num_vertices * 3;
    vbo->normal_data = new GLfloat[vbo->normal_size];
    vbo->flag|=VBO_NORMAL;

    if(mesh->hasTexture())
    {
      vbo->texcoord_size = vbo->num_vertices * 2;
      vbo->texcoord_data = new GLfloat[vbo->texcoord_size];
      vbo->flag|=VBO_TEXCOORD;
    }

    vbo->color_size = vbo->num_vertices * 3;
    vbo->color_data = new GLubyte[vbo->color_size];
    vbo->flag|=VBO_COLOR;

    for (unsigned int i=0; i<vbo->num_vertices; ++i)
    {
      vbo->position_data[i * 3]     = (GLfloat)mesh->vertices[i]->p[0];
      vbo->position_data[i * 3 + 1] = (GLfloat)mesh->vertices[i]->p[1];
      vbo->position_data[i * 3 + 2] = (GLfloat)mesh->vertices[i]->p[2];

      vbo->normal_data[i * 3]     = (GLfloat)mesh->vertices[i]->n[0];
      vbo->normal_data[i * 3 + 1] = (GLfloat)mesh->vertices[i]->n[1];
      vbo->normal_data[i * 3 + 2] = (GLfloat)mesh->vertices[i]->n[2];

      if(mesh->hasTexture())
      {
        vbo->texcoord_data[i * 2]     = (GLfloat)mesh->vertices[i]->t[0];
        vbo->texcoord_data[i * 2 + 1] = (GLfloat)mesh->vertices[i]->t[1];
      }

      // copy color data
      vbo->color_data[i * 3]     = (GLubyte)mesh->vertices[i]->c[0];
      vbo->color_data[i * 3 + 1] = (GLubyte)mesh->vertices[i]->c[1];
      vbo->color_data[i * 3 + 2] = (GLubyte)mesh->vertices[i]->c[2];
    }

    for (unsigned int i=0; i<vbo->num_faces; ++i)
    {
      vbo->index_data[i * 3    ] = mesh->faces[i]->v(0);
      vbo->index_data[i * 3 + 1] = mesh->faces[i]->v(1);
      vbo->index_data[i * 3 + 2] = mesh->faces[i]->v(2);
    }

    if(mesh->hasTexture())
    {
      vbo->texture_width=mesh->teximage.columns();
      vbo->texture_height=mesh->teximage.rows();
      vbo->texture_size=vbo->texture_width*vbo->texture_height*3;
      vbo->texture_data=new GLubyte[vbo->texture_size];
      memcpy(vbo->texture_data,mesh->teximage.x,vbo->texture_size*sizeof(GLubyte));
      vbo->flag|=VBO_TEXTURE;
    }
  }
}

MeshSet3DVBONode::MeshSet3DVBONode( Renderer* renderer, const char* vbofilename )
:RenderNode(renderer)
{
  size_t res = 0;
  FILE *fp=fopen(vbofilename,"rb");
  if (fp==NULL)
  {
    printf("Open file %s failed\n",vbofilename);
    return;
  }
  res+=fread(&num_mesh,sizeof(num_mesh),1,fp);
  meshvbos=new MeshVBO[num_mesh];
  memset(meshvbos,0,sizeof(MeshVBO)*num_mesh);
  for (int i=0;i<num_mesh;i++)
    meshvbos[i].read(fp);
  fclose(fp);
}

MeshSet3DVBONode::MeshSet3DVBONode( Renderer* renderer, FILE* fp )
:RenderNode(renderer)
{
  size_t res = 0;
  res+=fread(&num_mesh,sizeof(num_mesh),1,fp);
  meshvbos=new MeshVBO[num_mesh];
  memset(meshvbos,0,sizeof(MeshVBO)*num_mesh);
  for (int i=0;i<num_mesh;i++)
    meshvbos[i].read(fp);
}

MeshSet3DVBONode::~MeshSet3DVBONode()
{
  delete[] meshvbos;
  meshvbos=NULL;
}

void MeshSet3DVBONode::render()
{
  glEnable(GL_COLOR_MATERIAL);
//   glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);


  if(m_params->draw_vertices)
    drawPointsVBO();
  CHECKGL

  if(m_params->draw_wireframe)
    drawWireFrameVBO();
  CHECKGL

  if(m_params->draw_faces)
    drawFacesVBO();
  CHECKGL
//   glDisable(GL_COLOR_MATERIAL);
}

void MeshSet3DVBONode::drawFacesVBO()
{
  glDisable(GL_LIGHTING);
  glLineWidth(2.0);
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

  int f=VBO_NORMAL;
  switch(m_params->color_mode)
  {
  case Parameters::NO_COLOR: break;
  case Parameters::VERTEX_COLOR: f|=VBO_COLOR; break;
  case Parameters::TEXTURE_COLOR: f|=VBO_TEXCOORD|VBO_TEXTURE;break;
  }

  for (int i=0;i<num_mesh;i++)
  {
    meshvbos[i].bind(f);
    glDrawElements(GL_TRIANGLES, meshvbos[i].num_faces*3, GL_UNSIGNED_INT, 0);
    meshvbos[i].unbind(f);
  }
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}

void MeshSet3DVBONode::drawPointsVBO()
{
  glDisable(GL_LIGHTING);

  int f=VBO_NORMAL;
  switch(m_params->color_mode)
  {
  case Parameters::NO_COLOR: break;
  case Parameters::VERTEX_COLOR: f|=VBO_COLOR; break;
  case Parameters::TEXTURE_COLOR: f|=VBO_TEXCOORD|VBO_TEXTURE;break;
  }

  for (int i=0;i<num_mesh;i++)
  {
    meshvbos[i].bind(f);
    glDrawArrays(GL_POINTS, 0, meshvbos[i].num_vertices);
    meshvbos[i].unbind(f);
  }

}

void MeshSet3DVBONode::drawWireFrameVBO()
{
  glDisable(GL_LIGHTING);
  glLineWidth(2.0);
  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

  int f=VBO_NORMAL;
  switch(m_params->color_mode)
  {
  case Parameters::NO_COLOR: break;
  case Parameters::VERTEX_COLOR: f|=VBO_COLOR; break;
  case Parameters::TEXTURE_COLOR: f|=VBO_TEXCOORD|VBO_TEXTURE;break;
  }

  for (int i=0;i<num_mesh;i++)
  {
    meshvbos[i].bind(f);
    glDrawElements(GL_TRIANGLES, meshvbos[i].num_faces*3, GL_UNSIGNED_INT, 0);
    meshvbos[i].unbind(f);
  }
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}

void MeshSet3DVBONode::loadToGPU()
{
  for (int i=0;i<num_mesh;i++)
    meshvbos[i].loadGPU();
}

void MeshSet3DVBONode::unloadGPU()
{
  for (int i=0;i<num_mesh;i++)
    meshvbos[i].unloadGPU();
}

void MeshSet3DVBONode::writeToFile( const char *filename )
{
  FILE *fp=fopen(filename,"wb");
  if (fp==NULL)
  {
    printf("Open file %s failed\n",filename);
    return;
  }
  write(fp);
  fclose(fp);
}

void MeshSet3DVBONode::write( FILE* fp )
{
  fwrite(&num_mesh,sizeof(num_mesh),1,fp);
  for (int i=0;i<num_mesh;i++)
    meshvbos[i].write(fp);
}


void MeshSet3DVBONode::MeshVBO::read( FILE* fp )
{
  size_t res = 0;
  memset(this,0,sizeof(MeshSet3DVBONode::MeshVBO));
  res+=fread(&flag,sizeof(flag),1,fp);
  res+=fread(&num_vertices,sizeof(num_vertices),1,fp);
  res+=fread(&num_faces,sizeof(num_faces),1,fp);

  res+=fread(&position_size,sizeof(position_size),1,fp);
  position_data=new GLfloat[position_size];
  res+=fread(position_data,sizeof(GLfloat),position_size,fp);

  res+=fread(&index_size,sizeof(index_size),1,fp);
  index_data=new GLuint[index_size];
  res+=fread(index_data,sizeof(GLuint),index_size,fp);

  if ((flag&VBO_NORMAL)!=0)
  {
    res+=fread(&normal_size,sizeof(normal_size),1,fp);
    normal_data=new GLfloat[normal_size];
    res+=fread(normal_data,sizeof(GLfloat),normal_size,fp);
  }
  if ((flag&VBO_COLOR)!=0)
  {
    res+=fread(&color_size,sizeof(color_size),1,fp);
    color_data=new GLubyte[color_size];
    res+=fread(color_data,sizeof(GLubyte),color_size,fp);
  }
  if ((flag&VBO_TEXCOORD)!=0)
  {
    res+=fread(&texcoord_size,sizeof(texcoord_size),1,fp);
    texcoord_data=new GLfloat[texcoord_size];
    res+=fread(texcoord_data,sizeof(GLfloat),texcoord_size,fp);
  }
  if ((flag&VBO_TEXTURE)!=0)
  {
    res+=fread(&texture_size,sizeof(texture_size),1,fp);
    texture_data=new GLubyte[texture_size];
    res+=fread(texture_data,sizeof(GLubyte),texture_size,fp);
    res+=fread(&texture_width,sizeof(texture_width),1,fp);
    res+=fread(&texture_height,sizeof(texture_height),1,fp);
  }
}

void MeshSet3DVBONode::MeshVBO::write( FILE* fp )
{
  fwrite(&flag,sizeof(flag),1,fp);
  fwrite(&num_vertices,sizeof(num_vertices),1,fp);
  fwrite(&num_faces,sizeof(num_faces),1,fp);
  fwrite(&position_size,sizeof(position_size),1,fp);
  fwrite(position_data,sizeof(GLfloat),position_size,fp);
  fwrite(&index_size,sizeof(index_size),1,fp);
  fwrite(index_data,sizeof(GLuint),index_size,fp);
  if ((flag&VBO_NORMAL)!=0)
  {
    fwrite(&normal_size,sizeof(normal_size),1,fp);
    fwrite(normal_data,sizeof(GLfloat),normal_size,fp);
  }
  if ((flag&VBO_COLOR)!=0)
  {
    fwrite(&color_size,sizeof(color_size),1,fp);
    fwrite(color_data,sizeof(GLubyte),color_size,fp);
  }
  if ((flag&VBO_TEXCOORD)!=0)
  {
    fwrite(&texcoord_size,sizeof(texcoord_size),1,fp);
    fwrite(texcoord_data,sizeof(GLfloat),texcoord_size,fp);
  }
  if ((flag&VBO_TEXTURE)!=0)
  {
    fwrite(&texture_size,sizeof(texture_size),1,fp);
    fwrite(texture_data,sizeof(GLubyte),texture_size,fp);
    fwrite(&texture_width,sizeof(texture_width),1,fp);
    fwrite(&texture_height,sizeof(texture_height),1,fp);
  }
}

void MeshSet3DVBONode::MeshVBO::loadGPU()
{
  CHECKGL
  getGPUBuffer(position_buffer);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, position_buffer);
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, position_size*sizeof(GLfloat), position_data, GL_STATIC_DRAW_ARB);
  CHECKGL

  getGPUBuffer(index_buffer);
  glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, index_buffer);
  glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, index_size*sizeof(GLuint), index_data, GL_STATIC_DRAW_ARB);
  glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
  CHECKGL

  if ((flag&VBO_NORMAL)!=0)
  {
    getGPUBuffer(normal_buffer);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, normal_buffer);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, normal_size*sizeof(GLfloat), normal_data, GL_STATIC_DRAW_ARB);
  }
  CHECKGL

  if ((flag&VBO_COLOR)!=0)
  {
    getGPUBuffer(color_buffer);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, color_buffer);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, color_size*sizeof(GLubyte), color_data, GL_STATIC_DRAW_ARB);
  }
  CHECKGL

  if ((flag&VBO_TEXCOORD)!=0)
  {
    getGPUBuffer(texcoord_buffer);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, texcoord_buffer);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, texcoord_size*sizeof(GLfloat), texcoord_data, GL_STATIC_DRAW_ARB);
  }
  CHECKGL
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

  if ((flag&VBO_TEXTURE)!=0)
  {
    getTextureId(texture_id);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glBindTexture(GL_TEXTURE_2D, texture_id);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,texture_width,texture_height,0,GL_RGB,GL_UNSIGNED_BYTE,texture_data);
    glDisable(GL_TEXTURE_2D);
  }
  CHECKGL

}

void MeshSet3DVBONode::MeshVBO::unloadGPU()
{
  retGPUBuffer(position_buffer);
  retGPUBuffer(index_buffer);

  if ((flag&VBO_NORMAL)!=0)
  {
    retGPUBuffer(normal_buffer);
  }

  if ((flag&VBO_COLOR)!=0)
  {
    retGPUBuffer(color_buffer);
  }

  if ((flag&VBO_TEXCOORD)!=0)
  {
    retGPUBuffer(texcoord_buffer);
  }

  if ((flag&VBO_TEXTURE)!=0)
  {
    retTextureId(texture_id);
  }
}

void MeshSet3DVBONode::MeshVBO::bind( unsigned int vbo )
{
  glEnableClientState(GL_VERTEX_ARRAY);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, position_buffer);
  glVertexPointer(3, GL_FLOAT, 0, 0);

  glEnableClientState(GL_INDEX_ARRAY);
  glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, index_buffer);
  glIndexPointer(GL_INT, 0, 0);

  if ((vbo&VBO_NORMAL)!=0 && (flag&VBO_NORMAL)!=0)
  {
    glEnableClientState(GL_NORMAL_ARRAY);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, normal_buffer);
    glNormalPointer(GL_FLOAT, 0, 0);
  }

  if ((vbo&VBO_COLOR)!=0 && (flag&VBO_COLOR)!=0)
  {
    glDisable(GL_TEXTURE_2D);
    glEnableClientState(GL_COLOR_ARRAY);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, color_buffer);
    glColorPointer(3, GL_UNSIGNED_BYTE, 0, 0);
  }

  if ((vbo&VBO_TEXCOORD)!=0 && (flag&VBO_TEXCOORD)!=0)
  {
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, texcoord_buffer);
    glTexCoordPointer(2, GL_FLOAT, 0, 0);
    glColor3f(1,1,1);
  }

  if ((vbo&VBO_TEXTURE)!=0 && (flag&VBO_TEXTURE)!=0)
  {
    glEnable(GL_TEXTURE_2D);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture_id);
  }
}

void MeshSet3DVBONode::MeshVBO::unbind( unsigned int vbo )
{
  glDisableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_INDEX_ARRAY);
  if ((vbo&VBO_NORMAL)!=0)
  {
    glDisableClientState(GL_NORMAL_ARRAY);
  }
  if ((vbo&VBO_COLOR)!=0)
  {
    glDisableClientState(GL_COLOR_ARRAY);
  }
  if ((vbo&VBO_TEXCOORD)!=0)
  {
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  }
  if ((vbo&VBO_TEXTURE)!=0)
  {
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, 0);
    glDisable(GL_TEXTURE_2D);
  }
}

MeshSet3DVBONode::MeshVBO::~MeshVBO()
{
  delete position_data;
  delete normal_data;
  delete color_data;
  delete texcoord_data;
  delete index_data;
  delete texture_data;
}
std::vector<GLuint> MeshSet3DVBONode::gpubuffers;
std::vector<GLuint> MeshSet3DVBONode::gputextures;
void MeshSet3DVBONode::getGPUBuffer(GLuint &buffer)
{
  if (gpubuffers.empty())
  {
    glGenBuffersARB(1, &buffer);
    CHECKGL
  }
  else
  {
    buffer=gpubuffers.back();
    gpubuffers.pop_back();
  }
}
void MeshSet3DVBONode::retGPUBuffer(GLuint &buffer)
{
  gpubuffers.push_back(buffer);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffer);
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, 0, NULL, GL_STATIC_DRAW_ARB);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB,0);
  buffer=0;
}
void MeshSet3DVBONode::getTextureId(GLuint &texid)
{
  if (gputextures.empty())
  {
    glGenTextures(1, &texid);
  }
  else
  {
    texid=gputextures.back();
    gputextures.pop_back();
  }
}
void MeshSet3DVBONode::retTextureId(GLuint &texid)
{
  gputextures.push_back(texid);
//   glBindTexture(GL_TEXTURE_2D, texid);
//   glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,0,0,0,GL_RGB,GL_UNSIGNED_BYTE,NULL);
//   glBindTexture(GL_TEXTURE_2D, 0);
//   glDisable(GL_TEXTURE_2D);
  texid=0;
}

}