rtcMeshSet3DNode.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 .......: MeshSet3DNode.cpp
 * authors ....: Benjamin Pitzer
 * organization: Robert Bosch LLC
 * creation ...: 09/04/2008
 * modified ...: $Date: 2009-09-10 19:23:45 -0700 (Thu, 10 Sep 2009) $
 * changed by .: $Author: benjaminpitzer $
 * revision ...: $Revision: 917 $
 */

//== INCLUDES ==================================================================
#include <GL/glew.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "rtc/rtcRenderer.h"
#include "rtc/rtcBoundingBox.h"
#include "rtc/rtcMesh3DNode.h"
#include "rtc/rtcMeshSet3DNode.h"

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

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

// constructor
MeshSet3DNode::MeshSet3DNode(Renderer* renderer, MeshSet3D* meshset)
: RenderNode(renderer)
{
  // setup color table
  setupColorTable();
  // initialize
  initialize(meshset);
}

MeshSet3DNode::MeshSet3DNode(Renderer* renderer, const char* filename)
: RenderNode(renderer)
{
  // setup color table
  setupColorTable();
  // initialize
  initialize(filename);
}

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

void MeshSet3DNode::initialize(MeshSet3D* meshset)
{
  RenderNode::initialize();
  for (unsigned int i=0;i<meshset->meshes.size();i++) {
    Mesh3D* mesh = meshset->meshes[i];
    Mesh3DNode* node = new Mesh3DNode(m_renderer,mesh);
    Transformf transform = meshset->meshes[i]->pose.getTransform();
    node->setTransform(transform);
    nodes.push_back(node);
  }
}

void MeshSet3DNode::initialize(const char* filename)
{
  size_t res = 0;
  int flags;
  Point3Df topleft,bottomright;
  int num_meshes;
  RenderNode::initialize();

  FILE *fp=fopen(filename,"rb");
  if (fp==NULL) rtc_die("Cannot open file %s\n",filename);

  // read meshset header
  res+=fread(&flags,sizeof(flags),1,fp);
  res+=fread(&num_meshes,sizeof(num_meshes),1,fp);
  // load meshes
  for(int i=0;i<num_meshes;++i) {
    Mesh3D* mesh = new Mesh3D();
    mesh->read(fp);
    Mesh3DNode* node = new Mesh3DNode(m_renderer,mesh);
    Transformf transform = mesh->pose.getTransform();
    node->setTransform(transform);
    nodes.push_back(node);
    // free memory
    delete mesh;
  }
  // don't have to read AABB here
  fclose(fp);
}

void MeshSet3DNode::rebuild(MeshSet3D* meshset)
{
  clear();
  initialize(meshset);
}

void MeshSet3DNode::rebuild(const char* filename)
{
  clear();
  initialize(filename);
}

void MeshSet3DNode::setupColorTable()
{
  // Define reference colors used for drawing meshes, etc.
  ref_colors.setSize(7);
  float a = 0.6f;
//  ref_colors(0) = Vec4<float>(a,a,a,1.0);
//  ref_colors(1) = Vec4<float>(0.5*a,a,a,1.0);
  ref_colors(0) = Vec4<float>(101.0/255.0,144.0/255.0,191.0/255.0,1.0);
  ref_colors(1) = Vec4<float>(211.0/255.0,228.0/255.0,191.0/255.0,1.0);
//   ref_colors(0) = Vec4<float>(150.0/255.0,215.0/255.0,150.0/255.0,1.0);
//   ref_colors(1) = Vec4<float>(101.0/255.0,144.0/255.0,191.0/255.0,1.0);
  ref_colors(2) = Vec4<float>(a,0.5*a,a,1.0);
  ref_colors(3) = Vec4<float>(a,a,0.5*a,1.0);
  ref_colors(4) = Vec4<float>(0.5*a,0.5*a,a,1.0);
  ref_colors(5) = Vec4<float>(0.5*a,a,0.5*a,1.0);
  ref_colors(6) = Vec4<float>(a,0.5*a,0.5*a,1.0);
}

void MeshSet3DNode::clear()
{
  RenderNode::clear();
  for (unsigned int i=0;i<nodes.size();i++) delete nodes[i];
  nodes.clear();
}

void MeshSet3DNode::render()
{
  for (unsigned int i=0;i<nodes.size();i++) {
    nodes[i]->preRender();

    if(nodes[i]->getParameters().highlite)
      glColor3f(1.0,1.0,0.0); // yellow
    else {
      switch(nodes[i]->getParameters().color_mode)
      {
      case RenderNode::Parameters::NO_COLOR:
        glColor3f(1,1,1);
        break;
      case RenderNode::Parameters::VERTEX_COLOR:
        glColor3f(1,1,1);
        break;
      case RenderNode::Parameters::TEXTURE_COLOR:
        glColor3f(1,1,1);
        break;
      default:
        glColor3f(1,1,1);
        break;
      }
    }

    nodes[i]->render();
    nodes[i]->postRender();
  }
}

void MeshSet3DNode::preRender()
{
  RenderNode::preRender();
  m_renderer->switchTo3DMode();
}

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

void MeshSet3DNode::displayFaces(bool b)
{
  RenderNode::displayFaces(b);
  for (unsigned int i=0;i<nodes.size();i++) {
    nodes[i]->displayFaces(b);
  }
}

void MeshSet3DNode::displayVertices(bool b)
{
  RenderNode::displayVertices(b);
  for (unsigned int i=0;i<nodes.size();i++) {
    nodes[i]->displayVertices(b);
  }
}

void MeshSet3DNode::displayWireframe(bool b)
{
  RenderNode::displayWireframe(b);
  for (unsigned int i=0;i<nodes.size();i++) {
    nodes[i]->displayWireframe(b);
  }
}

void MeshSet3DNode::setColorMode(Parameters::ColorMode b)
{
  RenderNode::setColorMode(b);
  for (unsigned int i=0;i<nodes.size();i++) {
    nodes[i]->setColorMode(b);
  }
}

// draws n-th mesh in a highlite color
void MeshSet3DNode::highliteMesh(int n)
{
  for (unsigned int i=0;i<nodes.size();i++) {
    nodes[i]->setHighlite(false);
  }
  if(n>=0 && n<(int)nodes.size())
    nodes[n]->setHighlite(true);
}

// get the n-th child
Mesh3DNode* MeshSet3DNode::getChild(int n)
{
  return nodes[n];
}

void MeshSet3DNode::unloadGPU()
{
  for (size_t i=0;i<nodes.size();i++)
    nodes[i]->unloadGPU();
}
void MeshSet3DNode::loadToGPU()
{
  for (size_t i=0;i<nodes.size();i++)
    nodes[i]->loadToGPU();
}
//==============================================================================
} // namespace puma
//==============================================================================