SoTessellated Class Reference

#include <SoTessellated.h>

Inheritance diagram for SoTessellated:

Collaboration diagram for SoTessellated:

Public Member Functions
void	addTriangularFacet (double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3)
void	addQuadrangularFacet (double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3, double x4, double y4, double z4)
void	finalize ()
	SoTessellated ()
virtual void	generateAlternateRep ()
virtual void	clearAlternateRep ()

Static Public Member Functions
static void	initClass ()

Public Attributes
SoSFBool	drawEdgeLines
SoSFBool	forceEdgeLinesInBaseColour
SoSFNode	alternateRep

Protected Member Functions
virtual void	computeBBox (SoAction *action, SbBox3f &box, SbVec3f &center)
virtual void	generatePrimitives (SoAction *action)
virtual	~SoTessellated ()

Private Member Functions
	SO_NODE_HEADER (SoTessellated)
void	setupDefaultPoints ()

Private Attributes
std::vector< float >	m_points
std::vector< float >	m_normals
SbBox3f	m_bbox
SbVec3f	m_center

Detailed Description

Definition at line 23 of file SoTessellated.h.

Constructor & Destructor Documentation

SoTessellated()

SoTessellated::SoTessellated

(

)

Definition at line 28 of file SoTessellated.cxx.

{
  SO_NODE_CONSTRUCTOR(SoTessellated);
  SO_NODE_ADD_FIELD(drawEdgeLines, (false));
  SO_NODE_ADD_FIELD(forceEdgeLinesInBaseColour, (true));
  SO_NODE_ADD_FIELD(alternateRep,(NULL));
  setNodeType(EXTENSION);
}

~SoTessellated()

SoTessellated::~SoTessellated ( )

protectedvirtual

Definition at line 38 of file SoTessellated.cxx.

{
}

Member Function Documentation

addQuadrangularFacet()

void SoTessellated::addQuadrangularFacet	(	double	x1,
		double	y1,
		double	z1,
		double	x2,
		double	y2,
		double	z2,
		double	x3,
		double	y3,
		double	z3,
		double	x4,
		double	y4,
		double	z4 )

Definition at line 71 of file SoTessellated.cxx.

{
  addTriangularFacet(x1,y1,z1,x2,y2,z2,x3,y3,z3);
  addTriangularFacet(x3,y3,z3,x4,y4,z4,x1,y1,z1);
}

addTriangularFacet()

void SoTessellated::addTriangularFacet	(	double	x1,
		double	y1,
		double	z1,
		double	x2,
		double	y2,
		double	z2,
		double	x3,
		double	y3,
		double	z3 )

Definition at line 43 of file SoTessellated.cxx.

{
  m_points.push_back(x1);
  m_points.push_back(y1);
  m_points.push_back(z1);
  m_points.push_back(x2);
  m_points.push_back(y2);
  m_points.push_back(z2);
  m_points.push_back(x3);
  m_points.push_back(y3);
  m_points.push_back(z3);
 
  // Normal (v2-v1)(x)(v3-v1)
  const double edge1X(x2-x1), edge1Y(y2-y1), edge1Z(z2-z1);
  const double edge2X(x3-x1), edge2Y(y3-y1), edge2Z(z3-z1);
  double nx(edge1Y*edge2Z-edge1Z*edge2Y);
  double ny(edge1Z*edge2X-edge1X*edge2Z);
  double nz(edge1X*edge2Y-edge1Y*edge2X);
  double nl(nx*nx+ny*ny+nz*nz);
  const double s(1.0/sqrt(nl));
  m_normals.push_back(nx*s);
  m_normals.push_back(ny*s);
  m_normals.push_back(nz*s);
}

clearAlternateRep()

void SoTessellated::clearAlternateRep ( )

virtual

Definition at line 250 of file SoTessellated.cxx.

{
  alternateRep.setValue(NULL);
}

computeBBox()

void SoTessellated::computeBBox ( SoAction * action, SbBox3f & box, SbVec3f & center )

protectedvirtual

Definition at line 188 of file SoTessellated.cxx.

                                                                         {
  if(m_points.size()==0)
    setupDefaultPoints();
  box = m_bbox;
  center = m_center;
}

finalize()

void SoTessellated::finalize

(

)

Definition at line 81 of file SoTessellated.cxx.

{
  if(m_points.size()==0)
    setupDefaultPoints();
 
  //Bounding Box and Center
  float xmin(m_points[0]), ymin(m_points[1]), zmin(m_points[2]);
  float xmax(xmin), ymax(ymin), zmax(zmin);
 
  int nVertices = m_points.size()/3;
  for (int i=1;i<nVertices;i++) {
    xmin = std::min(xmin,m_points[i*3]);
    xmax = std::max(xmax,m_points[i*3]);
    ymin = std::min(ymin,m_points[i*3+1]);
    ymax = std::max(ymax,m_points[i*3+1]);
    zmin = std::min(zmin,m_points[i*3+2]);
    zmax = std::max(zmax,m_points[i*3+2]);
  }
 
  m_bbox.setBounds (xmin, ymin, zmin, xmax, ymax, zmax);
  m_center.setValue(0.5*(xmin+xmax),0.5*(ymin+ymax),0.5*(zmin+zmax));
 
  drawEdgeLines.touch();
}

generateAlternateRep()

void SoTessellated::generateAlternateRep ( )

virtual

Definition at line 196 of file SoTessellated.cxx.

{
  if(m_points.size()==0)
    setupDefaultPoints();
  if (alternateRep.getValue())
    clearAlternateRep();
 
  SoSeparator * sep = new SoSeparator;
 
  // Faceset representing the shape
  SoVertexProperty* vertices = new SoVertexProperty();
  for(size_t i=0;i<m_normals.size();++i)
    vertices->vertex.set1Value(i,m_points[i*3+0],m_points[i*3+1],m_points[i*3+2]);
  SoIndexedFaceSet* faceset = new SoIndexedFaceSet;
  int j=0;
  for(size_t i=0;i<m_normals.size();++i) {
    faceset->coordIndex.set1Value(j++,i);
    if((i>1) && ((i-2)%3==0)) {
      faceset->coordIndex.set1Value(j++,SO_END_FACE_INDEX);
    }
  }
 
  faceset->vertexProperty = vertices;
  sep->addChild(faceset);
 
  // Lineset representing the outline
  //
  // -- ToDo: this can be optimizid. We are currently drawing edges twice 
  // -- and we could also eliminate 'diagonal' lines coming from
  // -- quadrangular shapes
  //
  if (drawEdgeLines.getValue()) {
    SoVertexProperty* verticesL = new SoVertexProperty();
    SoIndexedLineSet* lineset = new SoIndexedLineSet;
    int kk=0, jj=0;
    for(size_t i=0;i<m_points.size()-9;i+=9) {
      verticesL->vertex.set1Value(kk,m_points[i],m_points[i+1],m_points[i+2]);
      lineset->coordIndex.set1Value(jj++,kk++);
      verticesL->vertex.set1Value(kk,m_points[i+3],m_points[i+4],m_points[i+5]);
      lineset->coordIndex.set1Value(jj++,kk++);
      verticesL->vertex.set1Value(kk,m_points[i+6],m_points[i+7],m_points[i+8]);
      lineset->coordIndex.set1Value(jj++,kk++);
      verticesL->vertex.set1Value(kk,m_points[i],m_points[i+1],m_points[i+2]);
      lineset->coordIndex.set1Value(jj++,kk++);
      lineset->coordIndex.set1Value(jj++,SO_END_LINE_INDEX);
    }
    lineset->vertexProperty = verticesL;
    sep->addChild(lineset);
  }
 
  alternateRep.setValue(sep);
}

generatePrimitives()

void SoTessellated::generatePrimitives ( SoAction * action )

protectedvirtual

Definition at line 108 of file SoTessellated.cxx.

{
  if(m_points.size()==0)
    setupDefaultPoints();
 
  // Access the state from the action
  SoState *state = action->getState();
 
  if(action->getTypeId().isDerivedFrom(SoPickAction::getClassTypeId())) {
 
    //For picking:
    SoPrimitiveVertex vertex;
    beginShape(action,TRIANGLES);
    for(size_t i=0;i<m_points.size();i+=3) {
      vertex.setPoint(SbVec3f(m_points[i],m_points[i+1],m_points[i+2]));
      shapeVertex(&vertex);
    }
    endShape();
 
  }else{
 
    // Draw the shape itself
    glBegin(GL_TRIANGLES);
    int nFaces = m_normals.size()/3;
    for (int i=0;i<nFaces;i++) {
      glNormal3fv(static_cast<const GLfloat*>(&m_normals[i*3]));
      for (int j = 0; j < 3; j++)
          glVertex3fv(static_cast<const GLfloat*>(&m_points[i*9+j*3]));
    }
    glEnd();
 
    // Draw edges if required
    // 
    // -- ToDo: this can be optimizid. We are currently drawing edges twice 
    // -- and we could also eliminate 'diagonal' lines coming from
    // -- quadrangular shapes
    //
    if(drawEdgeLines.getValue()){
      const bool disableLighting(forceEdgeLinesInBaseColour.getValue()&&glIsEnabled(GL_LIGHTING));
      const bool transparencyOn = glIsEnabled(GL_BLEND);
 
      if (disableLighting) glDisable(GL_LIGHTING);
      if (transparencyOn) glDisable(GL_BLEND);
 
      for(size_t i=0;i<m_points.size()-9;i+=9) {
    glBegin(GL_LINE_STRIP);
    glVertex3fv(static_cast<const GLfloat*>(&m_points[i]));
    glVertex3fv(static_cast<const GLfloat*>(&m_points[i+3]));
    glVertex3fv(static_cast<const GLfloat*>(&m_points[i+6]));
    glVertex3fv(static_cast<const GLfloat*>(&m_points[i]));
    glEnd();
      }
 
      if (disableLighting) glEnable(GL_LIGHTING);
      if (transparencyOn) glEnable(GL_BLEND);
    }
  }
 
  if (state&&state->isElementEnabled(SoGLCacheContextElement::getClassStackIndex())) {
    //Encourage auto caching
    SoGLCacheContextElement::shouldAutoCache(state, SoGLCacheContextElement::DO_AUTO_CACHE);
#if ((COIN_MAJOR_VERSION>=3)||((COIN_MAJOR_VERSION==2)&&(COIN_MINOR_VERSION>=5)))
    SoGLCacheContextElement::incNumShapes(state);
#endif
  }
 
}

initClass()

void SoTessellated::initClass ( )

static

Definition at line 19 of file SoTessellated.cxx.

{
  [[maybe_unused]] static const bool didInit = [&]() {
    SO_NODE_INIT_CLASS(SoTessellated, SoShape, "Shape");
    return true;
  }();
}

setupDefaultPoints()

void SoTessellated::setupDefaultPoints ( )

private

Definition at line 177 of file SoTessellated.cxx.

{
  double targetSize = 100.;
  addTriangularFacet(-targetSize,-targetSize,0.,targetSize,-targetSize,0.,0.,0.,targetSize);
  addTriangularFacet(targetSize,-targetSize,0.,targetSize,targetSize,0.,0.,0.,targetSize);
  addTriangularFacet(targetSize,targetSize,0.,-targetSize,targetSize,0.,0.,0.,targetSize);
  addTriangularFacet(-targetSize,targetSize,0.,-targetSize,-targetSize,0.,0.,0.,targetSize);
  addQuadrangularFacet(-targetSize,-targetSize,0.,-targetSize,targetSize,0.,targetSize,targetSize,0.,targetSize,-targetSize,0.);
}

SO_NODE_HEADER()

SoTessellated::SO_NODE_HEADER ( SoTessellated )

private

Member Data Documentation

alternateRep

SoSFNode SoTessellated::alternateRep

Definition at line 33 of file SoTessellated.h.

drawEdgeLines

SoSFBool SoTessellated::drawEdgeLines

Definition at line 31 of file SoTessellated.h.

forceEdgeLinesInBaseColour

SoSFBool SoTessellated::forceEdgeLinesInBaseColour

Definition at line 32 of file SoTessellated.h.

m_bbox

SbBox3f SoTessellated::m_bbox

private

Definition at line 74 of file SoTessellated.h.

m_center

SbVec3f SoTessellated::m_center

private

Definition at line 75 of file SoTessellated.h.

m_normals

std::vector<float> SoTessellated::m_normals

private

Definition at line 73 of file SoTessellated.h.

m_points

std::vector<float> SoTessellated::m_points

private

Definition at line 72 of file SoTessellated.h.

---

The documentation for this class was generated from the following files:

• SoTessellated.h
• SoTessellated.cxx