rtcMesh3DNode.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 .......: Mesh3DNode.cpp
 * authors ....: Benjamin Pitzer
 * organization: Robert Bosch LLC
 * creation ...: 04/16/2007
 * modified ...: $Date: 2009-09-11 00:34:59 -0700 (Fri, 11 Sep 2009) $
 * changed by .: $Author: benjaminpitzer $
 * revision ...: $Revision: 918 $
 */

//== INCLUDES ==================================================================
#define GL_GLEXT_PROTOTYPES
#include <GL/glew.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "rtc/rtcMesh3DNode.h"

//== NAMESPACES ================================================================
namespace rtc {

//== IMPLEMENTATION ============================================================

// constructor
Mesh3DNode::Mesh3DNode(Renderer* renderer, Mesh3D* mesh)
: RenderNode(renderer), has_texture(false), num_vertices(0), num_faces(0),
  position_buffer(0), position_size(0), position_data(NULL),
  index_buffer(0), index_size(0), index_data(NULL), pose(mesh->pose)
{
  // initialize
  initialize(mesh);
}

// destructor
Mesh3DNode::~Mesh3DNode()
{
  clear();
}

void Mesh3DNode::initialize(Mesh3D* mesh)
{
  RenderNode::initialize();
  int n;
  num_vertices = mesh->vertices.size();
  num_faces = mesh->faces.size();

  // generate data arrays
  position_size = num_vertices * 3 * sizeof(GLfloat);
  position_data = (GLfloat*)malloc(position_size);

  normal_size = num_vertices * 3 * sizeof(GLfloat);
  normal_data = (GLfloat*)malloc(normal_size);

  index_size = num_faces * 3 * sizeof(GLuint);
  index_data = (GLuint*)malloc(index_size);

  if(mesh->hasTexture()) {
    // create vertex color array
    texture_coordinate_size = num_vertices * 2 * sizeof(GLfloat);
    texture_coordinate_data = (GLfloat*)malloc(texture_coordinate_size);
    has_texture = true;
  }

  // create vertex color array
  color_size = num_vertices * 3 * sizeof(GLubyte);
  color_data = (GLubyte*)malloc(color_size);

  int* vertex_map = new int[num_vertices];

  // iterate through all vertices
  n=0;
  for (unsigned int i=0; i<num_vertices; ++i) {
    if(mesh->vertices[i]->hidden()) {
      vertex_map[i] = -1;
    }
    else {
      Vec3f p=mesh->vertices[i]->p;
      // copy position data
      position_data[n * 3]     = (GLfloat)p[0];
      position_data[n * 3 + 1] = (GLfloat)p[1];
      position_data[n * 3 + 2] = (GLfloat)p[2];

      Vec3f nor=mesh->vertices[i]->n;
      // copy normal data
      normal_data[n * 3]     = (GLfloat)nor[0];
      normal_data[n * 3 + 1] = (GLfloat)nor[1];
      normal_data[n * 3 + 2] = (GLfloat)nor[2];

      if(mesh->hasTexture()) {
        // copy texture coordinate data
        texture_coordinate_data[n * 2]     = (GLfloat)mesh->vertices[i]->t[0];
        texture_coordinate_data[n * 2 + 1] = (GLfloat)mesh->vertices[i]->t[1];
      }

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

      vertex_map[i] = n;
      n++;
    }
  }
  num_vertices = n;

  n=0;
  for (unsigned int i=0; i<num_faces; ++i) {
    Face3D* f = mesh->faces[i];
    if(!f->hidden() &&
       !mesh->vertices[f->v(0)]->hidden() &&
       !mesh->vertices[f->v(1)]->hidden() &&
       !mesh->vertices[f->v(2)]->hidden()) {

      // assign index to vertex
      index_data[n * 3    ] = vertex_map[f->v(0)];
      index_data[n * 3 + 1] = vertex_map[f->v(1)];
      index_data[n * 3 + 2] = vertex_map[f->v(2)];

      n++;
    }
  }
  num_faces = n;

  position_size = num_vertices * 3 * sizeof(GLfloat);
  normal_size = num_vertices * 3 * sizeof(GLfloat);
  index_size = num_faces * 3 * sizeof(GLuint);
  color_size = num_vertices * 3 * sizeof(GLubyte);

  if(has_texture) {
    texture_coordinate_size = num_vertices * 2 * sizeof(GLfloat);
    teximage = mesh->teximage;
  }

  delete[] vertex_map;
}

void Mesh3DNode::clear()
{
  RenderNode::clear();

  unloadGPU();

  free(position_data);
  free(normal_data);
  if(has_texture) {
    free(texture_coordinate_data);
  }
  free(color_data);
  free(index_data);
}

void Mesh3DNode::render()
{
  // Set up nice color-tracking
  glEnable(GL_LIGHTING);
  glEnable(GL_COLOR_MATERIAL);
  glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

  if(m_params->draw_faces)
    drawFacesVBO();

  if(m_params->draw_vertices)
    drawPointsVBO();

  if(m_params->draw_wireframe)
    drawWireFrameVBO();

  // disable color material
  glDisable(GL_COLOR_MATERIAL);
}

void Mesh3DNode::preRender()
{
  RenderNode::preRender();
}

void Mesh3DNode::postRender()
{
  RenderNode::postRender();
}

void Mesh3DNode::drawPointsVBO()
{
  if (!m_is_initialized) loadToGPU();

  glDisable(GL_LIGHTING);

  bindVBO();
//  glColor3f(0.0,0.0,0.0);
  glDrawArrays(GL_POINTS, 0, num_vertices);

  unbindVBO();
}

void Mesh3DNode::drawFacesVBO()
{
  if (!m_is_initialized) loadToGPU();

  glEnable(GL_LIGHTING);
  //glEnable(GL_TEXTURE_2D);
  glEnableClientState(GL_NORMAL_ARRAY);
  bindVBO();
//  glColor3f(1.0,1.0,1.0);
  glDrawElements(GL_TRIANGLES, num_faces*3, GL_UNSIGNED_INT, (GLuint*)0+0);
  unbindVBO();
}

// Draws the actual m_mesh as wireframe
void Mesh3DNode::drawWireFrameVBO()
{
  if (!m_is_initialized) loadToGPU();

  glDisable(GL_LIGHTING);
  glLineWidth(1.0);
  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

  bindVBO();
  glDisable(GL_TEXTURE_2D);

  glDrawElements(GL_TRIANGLES, num_faces*3, GL_UNSIGNED_INT, (GLuint*)0+0);
  unbindVBO();
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}

void Mesh3DNode::drawPoints()
{
}

void Mesh3DNode::drawFaces()
{
}

void Mesh3DNode::drawWireFrame()
{
}

//=============================================================================
void Mesh3DNode::loadToGPU()
{
  // setup opengl buffer objects
  glGenBuffersARB(1, &position_buffer);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, position_buffer);
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, position_size, position_data, GL_STATIC_DRAW_ARB);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

  glGenBuffersARB(1, &normal_buffer);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, normal_buffer);
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, normal_size, normal_data, GL_STATIC_DRAW_ARB);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

  if(has_texture) {
    glGenBuffersARB(1, &texture_coordinate_buffer);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, texture_coordinate_buffer);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, texture_coordinate_size, texture_coordinate_data, GL_STATIC_DRAW_ARB);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
  }

  glGenBuffersARB(1, &color_buffer);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, color_buffer);
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, color_size, color_data, GL_STATIC_DRAW_ARB);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

  glGenBuffersARB(1, &index_buffer);
  glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, index_buffer);
  glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, index_size, index_data, GL_STATIC_DRAW_ARB);
  glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);

  if (has_texture && texture.texture_id==0) {
    texture.fromImage(teximage);
    teximage.reset();
  }

  m_is_initialized = true;
}

void Mesh3DNode::unloadGPU()
{
  if(m_is_initialized) {
    glDeleteBuffersARB(1, &position_buffer);
    glDeleteBuffersARB(1, &normal_buffer);
    if(has_texture)
      glDeleteBuffersARB(1, &texture_coordinate_buffer);
    glDeleteBuffersARB(1, &color_buffer);
    glDeleteBuffersARB(1, &index_buffer);
    m_is_initialized=false;
  }
}

void Mesh3DNode::bindVBO()
{
  if(!m_params->highlite) {
    switch(m_params->color_mode)
    {
    case Parameters::NO_COLOR:
      glDisable(GL_TEXTURE_2D);
      break;
    case Parameters::VERTEX_COLOR:
      glDisable(GL_TEXTURE_2D);
      glEnableClientState(GL_COLOR_ARRAY);
      break;
    case Parameters::TEXTURE_COLOR:
      if(has_texture) glEnableClientState(GL_TEXTURE_COORD_ARRAY);
      glEnable(GL_TEXTURE_2D);
      texture.bind();
      break;
    }
  }
  glEnableClientState(GL_VERTEX_ARRAY);
  glEnableClientState(GL_INDEX_ARRAY);

  // bind vertex normal buffer
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, normal_buffer);
  glNormalPointer(GL_FLOAT, 0, 0);

  if(!m_params->highlite) {
    // bind vertex colors
    switch(m_params->color_mode)
    {
    case Parameters::NO_COLOR:
      glColor3f(101.0/255.0,144.0/255.0,191.0/255.0);
      break;
    case Parameters::VERTEX_COLOR:
      glBindBufferARB(GL_ARRAY_BUFFER_ARB, color_buffer);
      glColorPointer(3, GL_UNSIGNED_BYTE, 0, 0);
      break;
    case Parameters::TEXTURE_COLOR:
      if(has_texture) {
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, texture_coordinate_buffer);
        glTexCoordPointer(2, GL_FLOAT, 0, 0);
        glColor3f(1,1,1);
      }
      break;
    }
  }

  // bind vertex buffer
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, position_buffer);
  glVertexPointer(3, GL_FLOAT, 0, 0);

  // bind face buffer
  glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, index_buffer);
  glIndexPointer(GL_INT, 0, 0);
}

void Mesh3DNode::unbindVBO()
{
  glDisableClientState(GL_NORMAL_ARRAY);
  if(!m_params->highlite) {
    switch(m_params->color_mode)
    {
    case Parameters::NO_COLOR:
      break;
    case Parameters::VERTEX_COLOR:
      glDisableClientState(GL_COLOR_ARRAY);
      break;
    case Parameters::TEXTURE_COLOR:
      if(has_texture) glDisableClientState(GL_TEXTURE_COORD_ARRAY);
      texture.unbind();
      glDisable(GL_TEXTURE);
      break;
    }
  }
  glDisableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_INDEX_ARRAY);
}

} // namespace puma

//=============================================================================