rtcVertex3D.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2007
 * Robert Bosch LLC
 * Research and Technology Center North America
 * Palo Alto, California
 *
 * All rights reserved.
 *
 *------------------------------------------------------------------------------
 * project ....: Autonomous Technologies
 * file .......: Vertex3D.cpp
 * authors ....: Benjamin Pitzer
 * organization: Robert Bosch LLC
 * creation ...: 02/29/2008
 * modified ...: $Date:2008-03-03 10:26:02 -0800 (Mon, 03 Mar 2008) $
 * changed by .: $Author:benjaminpitzer $
 * revision ...: $Revision:141 $
 */

//== INCLUDES ==================================================================
#include "rtc/rtcFace3D.h"
#include "rtc/rtcMesh3D.h"
#include "rtc/rtcVertex3D.h"

//==============================================================================
// NAMESPACE
namespace rtc {

Vertex3D::Vertex3D(Mesh3D* _mesh)
: IOObject(), mesh(_mesh),p(0,0,0),n(0,0,0),c(0,0,0),flags(0)
{
}

Vertex3D::Vertex3D(Mesh3D* _mesh, const Point3Df& _p)
: IOObject(), mesh(_mesh),p(_p),n(0,0,0),c(0,0,0),flags(0)
{
}

Vertex3D::~Vertex3D()
{
}

Vertex3D::Vertex3D(const Vertex3D& other)
: IOObject()
{
  mesh = other.mesh;
  p = other.p;
  n = other.n;
  c = other.c;
  flags = other.flags;
  faces = other.faces;
  t = other.t;
}

// calculate normal vector
void Vertex3D::update()
{
  if(faces.empty()) {
    n = Vec3f(1,0,0);
  }
  else {
    n.set(0.0f);
    for(unsigned int i=0;i<faces.size();++i) {
      n+=mesh->faces[faces[i]]->n;
    }
  }
  n.normalize();
}

// Mutators
void Vertex3D::set(Vec3f _p)
{
  set(_p.x[0],_p.x[1],_p.x[2]);
}

void Vertex3D::set(float x, float y, float z)
{
  p[0] = x; p[1] = y; p[2] = z;
}

bool Vertex3D::getFlag(int flag) const
{
  return (flags&flag);
}

void Vertex3D::setFlag(int flag, bool value)
{
  if(value)
    flags|=flag;
  else
    flags&=flag;
}

bool Vertex3D::boundary() const
{
  return getFlag(VERTEX_FLAG_BOUNDARY);
}

void Vertex3D::setBoundary(bool boundary)
{
  setFlag(VERTEX_FLAG_BOUNDARY,boundary);
}

bool Vertex3D::hidden() const
{
  return getFlag(VERTEX_FLAG_HIDDEN);
}

void Vertex3D::setHidden(bool hidden)
{
  setFlag(VERTEX_FLAG_HIDDEN,hidden);
}

bool Vertex3D::hasTexCoord() const
{
  return getFlag(VERTEX_FLAG_HAS_TEX_COORD);
}

bool Vertex3D::write(OutputHandler &oh) const
{
  rtc_write(oh,p);
  rtc_write(oh,n);
  rtc_write(oh,c);
  rtc_write(oh,"flags",flags);
  if(hasTexCoord()) rtc_write(oh,t);
  return true;
}

void Vertex3D::write( FILE *fp ) const
{
  fwrite(&p,sizeof(p),1,fp);
  fwrite(&n,sizeof(n),1,fp);
  fwrite(&c,sizeof(c),1,fp);
  fwrite(&flags,sizeof(flags),1,fp);
  if (hasTexCoord()) fwrite(&t,sizeof(t),1,fp);
}

bool Vertex3D::read(InputHandler &ih)
{
  rtc_read(ih,p);
  rtc_read(ih,n);
  rtc_read(ih,c);
  rtc_read(ih,"flags",flags);
  if(hasTexCoord()) rtc_read(ih,t);
  return true;
}

void Vertex3D::read( FILE *fp ) 
{
  size_t res = 0;
  res+=fread(&p,sizeof(p),1,fp);
  res+=fread(&n,sizeof(n),1,fp);
  res+=fread(&c,sizeof(c),1,fp);
  res+=fread(&flags,sizeof(flags),1,fp);
  if (hasTexCoord()) res+=fread(&t,sizeof(t),1,fp);
}

//==============================================================================
} // NAMESPACE rtc
//==============================================================================