SoTubs Class Reference

SoTubs - Inventor version of the G4Tubs Geant Geometry entity. More...

#include <SoTubs.h>

Inheritance diagram for SoTubs:

Collaboration diagram for SoTubs:

Public Member Functions
	SoTubs ()
	Constructor, required. More...
virtual void	generateAlternateRep ()
	Generate AlternateRep, required. More...
virtual void	clearAlternateRep ()
	We better be able to clear it, too! More...

Static Public Member Functions
static void	initClass ()
	Class Initializer, required. More...

Public Attributes
SoSFFloat	pRMin
	Inside radius of the tube. More...
SoSFFloat	pRMax
	Outside radius of the tube. More...
SoSFFloat	pDz
	Half-length in Z. More...
SoSFFloat	pSPhi
	Starting angle, in radians. More...
SoSFFloat	pDPhi
	Delta-angle, in radians. More...
SoSFInt32	pOverrideNPhi
	Override number of phi subdivision used for rendering shape (i.e. More...
SoSFNode	alternateRep
	Alternate rep - required. More...
SoSFBool	drawEdgeLines

Protected Member Functions
virtual void	computeBBox (SoAction *action, SbBox3f &box, SbVec3f &center)
	compute bounding Box, required More...
virtual void	generatePrimitives (SoAction *action)
	Generate Primitives, required. More...
virtual SoChildList *	getChildren () const
	GetChildList, required whenever the class has hidden children. More...

Private Member Functions
	SO_NODE_HEADER (SoTubs)
void	generateChildren ()
	Generate Children. More...
void	updateChildren ()
	Used to modify hidden children when a data field is changed. More...
void	inc (double &sinPhi, double &cosPhi, double sinDeltaPhi, double cosDeltaPhi) const
	help with trigonometry. increments sines an cosines by an angle. More...

Private Attributes
std::unique_ptr< SoChildList >	m_children
	ChildList. Required whenever the class has hidden children. More...

Detailed Description

SoTubs - Inventor version of the G4Tubs Geant Geometry entity.

Node: SoTubs

Description: The Inventor version of the G4Tubs Geant Geometry entity

Author: Joe Boudreau Nov 11 1996

The documentation from Geant says:

class G4Tubs

A tube or tube segment with curved sides parallel to the z-axis. The tube has a specified half-length along the z axis, about which it is centred, and a given minimum and maximum radius. A minimum radius of 0 signifies a filled tube /cylinder. The tube segment is specified by starting and delta angles for phi, with 0 being the +x axis, PI/2 the +y axis. A delta angle of 2PI signifies a complete, unsegmented tube/cylinder

Always use Inventor Fields. This allows Inventor to detect a change to the data field and take the appropriate action; e.g., redraw the scene.

Definition at line 52 of file SoTubs.h.

Constructor & Destructor Documentation

SoTubs()

SoTubs::SoTubs

(

)

Constructor, required.

Definition at line 40 of file SoTubs.cxx.

               {
 
 
  // This statement is required
  SO_NODE_CONSTRUCTOR(SoTubs);
 
  // Data fields are initialized like this:
  SO_NODE_ADD_FIELD(pRMin,               (0));
  SO_NODE_ADD_FIELD(pRMax,               (1));
  SO_NODE_ADD_FIELD(pDz,                 (10));
  SO_NODE_ADD_FIELD(pSPhi,               (0));
  SO_NODE_ADD_FIELD(pDPhi,               ((float)(2*M_PI)));
  SO_NODE_ADD_FIELD(pOverrideNPhi,       (0));
  SO_NODE_ADD_FIELD(alternateRep,        (NULL));
  SO_NODE_ADD_FIELD(drawEdgeLines,       (false));
 
  m_children = std::make_unique<SoChildList>(this);
 
  setNodeType(EXTENSION);
}

Member Function Documentation

clearAlternateRep()

void SoTubs::clearAlternateRep ( )

virtual

We better be able to clear it, too!

Definition at line 568 of file SoTubs.cxx.

                               {
  alternateRep.setValue(NULL);
}

computeBBox()

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

protectedvirtual

compute bounding Box, required

Definition at line 355 of file SoTubs.cxx.

                                                                  {
  RevolutionSurfaceUtil::setBBoxPars(pSPhi.getValue(), pDPhi.getValue(),
                     pRMin.getValue(), pRMax.getValue(),
                     -pDz.getValue(),pDz.getValue(),
                     box, center );
}

generateAlternateRep()

void SoTubs::generateAlternateRep ( )

virtual

Generate AlternateRep, required.

Generating an alternate representation must be done upon users request. It allows an Inventor program to read back the file without requiring this code to be dynamically linked. If the users expects that this code will be dynamically linked, he need not invoke this method.

Definition at line 557 of file SoTubs.cxx.

                                  {
 
  // This routine sets the alternate representation to the child
  // list of this mode.
 
  if (m_children->getLength() == 0) generateChildren();
  updateChildren();
  alternateRep.setValue((SoSeparator *)  ( *m_children)[0]);
}

generateChildren()

void SoTubs::generateChildren ( )

private

Generate Children.

Used to create the hidden children. Required whenever the node has hidden children.

Definition at line 533 of file SoTubs.cxx.

                              {
 
  // This routines creates one SoSeparator, one SoCoordinate3, and
  // one SoLineSet, and puts it in the child list.  This is done only
  // once, whereas redrawing the position of the coordinates occurs each
  // time an update is necessary, in the updateChildren routine.
 
  assert(m_children->getLength() ==0);
  SoSeparator      *sep              = new SoSeparator();
  SoCoordinate3    *theCoordinates   = new SoCoordinate3();
  SoNormal         *theNormals       = new SoNormal();
  SoNormalBinding  *theNormalBinding = new SoNormalBinding();
  SoIndexedFaceSet *theFaceSet       = new SoIndexedFaceSet();
  //
  // This line costs some in render quality! but gives speed.
  //
  sep->addChild(theCoordinates);
  sep->addChild(theNormals);
  sep->addChild(theNormalBinding);
  sep->addChild(theFaceSet);
  m_children->append(sep);
}

generatePrimitives()

void SoTubs::generatePrimitives ( SoAction *  action )

protectedvirtual

Generate Primitives, required.

Definition at line 72 of file SoTubs.cxx.

                                                {
  // This variable is used to store each vertex
  SoPrimitiveVertex pv;
 
  // Access the stat from the action
  SoState *state = action->getState();
  if (!state)
    return;
 
  // See if we have to use a texture coordinate function,
  // rather than generating explicit texture coordinates.
  SbBool useTexFunction=
    (SoTextureCoordinateElement::getType(state) ==
     SoTextureCoordinateElement::FUNCTION);
 
  // If we need to generate texture coordinates with a function,
  // we'll need an SoGLTextureCoordinateElement.  Otherwise, we'll
  // set up the coordinates directly.
  const SoTextureCoordinateElement* tce = NULL;
  SbVec4f texCoord;
  if (useTexFunction) {
    tce = SoTextureCoordinateElement::getInstance(state);
  }
  else {
    texCoord[2] = 0.0;
    texCoord[3] = 1.0;
  }
  SbVec3f point, normal;
 
 
  //-----------------------------------------------------
#define GEN_VERTEX(pv,x,y,z,s,t,nx,ny,nz)               \
  point.setValue((float)(x),(float)(y),(float)(z));     \
  normal.setValue((float)(nx),(float)(ny),(float)(nz)); \
  if (useTexFunction) {                                 \
    texCoord=tce->get(point,normal);                    \
  } else {                                              \
    texCoord[0]=(float)(s);                             \
    texCoord[1]=(float)(t);                             \
  }                                                     \
  pv.setPoint(point);                                   \
  pv.setNormal(normal);                                 \
  pv.setTextureCoords(texCoord);                        \
  shapeVertex(&pv);
  //-----------------------------------------------------
 
  int NPHI = RevolutionSurfaceUtil::nphiDivisions( pDPhi.getValue(), this->getComplexityValue(action), pOverrideNPhi.getValue() );
 
  double deltaPhi = pDPhi.getValue()/NPHI, phi0 = pSPhi.getValue(),phi1=phi0+pDPhi.getValue();
  double rMax=pRMax.getValue(),rMin=pRMin.getValue();
  double zMax=pDz.getValue(),zMin=-zMax;
  double cosPhi0=cos(phi0), sinPhi0=sin(phi0);
  double cosPhi1=cos(phi1), sinPhi1=sin(phi1);
  double cosDeltaPhi=cos(deltaPhi),sinDeltaPhi=sin(deltaPhi);
  const bool noPhiCutout=fabs(pDPhi.getValue())==0.F || fabs(fabs(pDPhi.getValue())-2.0*M_PI)<0.01; // FIXME - better way to do this?
  const bool disableLighting(glIsEnabled(GL_LIGHTING));
  const bool transparencyOn(glIsEnabled(GL_BLEND));
  
  //
  // The outer surface!
  //
  int i;
  double sinPhi,cosPhi;
  beginShape(action,TRIANGLE_STRIP);
  sinPhi=sinPhi0;
  cosPhi=cosPhi0;
  for (i = 0; i<=NPHI; i++) {
    GEN_VERTEX(pv,rMax*cosPhi,rMax*sinPhi,zMax,0.0,0.0,cosPhi,sinPhi,0);
    GEN_VERTEX(pv,rMax*cosPhi,rMax*sinPhi,zMin,1.0,1.0,cosPhi,sinPhi,0);
    inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
  }
  endShape();
  //
  // The inner surface!
  //
  if(rMin!=0.F) {
    beginShape(action,TRIANGLE_STRIP);
    sinPhi=sinPhi0;
    cosPhi=cosPhi0;
    for (i = 0; i<=NPHI; i++) {
      GEN_VERTEX(pv,rMin*cosPhi,rMin*sinPhi,zMax,0.0,0.0,-cosPhi,-sinPhi,0);
      GEN_VERTEX(pv,rMin*cosPhi,rMin*sinPhi,zMin,1.0,1.0,-cosPhi,-sinPhi,0);
      inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
    }
    endShape();
  }
//  if (fabs(deltaPhi)<2.0*M_PI) { // Old value - probably responsible for the funny internal stuff.
  if (!noPhiCutout) {
 
    //
    // The end - inner part of wedge
    //
    
    // FIXME - Use GL_POLYGON? Tried it - no change when selecting and seemed to mess up phong-type shading.
    // Try again, to see if it's faster?
    
    beginShape(action,TRIANGLE_STRIP);
    sinPhi=sinPhi0;
    cosPhi=cosPhi0;
    GEN_VERTEX(pv,rMax*cosPhi,rMax*sinPhi,zMax,0.0,0.0,sinPhi,-cosPhi,0);
    GEN_VERTEX(pv,rMax*cosPhi,rMax*sinPhi,zMin,1.0,1.0,sinPhi,-cosPhi,0);
    GEN_VERTEX(pv,rMin*cosPhi,rMin*sinPhi,zMax,1.0,0.0,sinPhi,-cosPhi,0);
    GEN_VERTEX(pv,rMin*cosPhi,rMin*sinPhi,zMin,0.0,1.0,sinPhi,-cosPhi,0);
    endShape();
    //
    // The other end
    //
    beginShape(action,TRIANGLE_STRIP);
    sinPhi=sinPhi1;
    cosPhi=cosPhi1;
    GEN_VERTEX(pv,rMax*cosPhi,rMax*sinPhi, zMax,0.0,0.0,-sinPhi,+cosPhi,0);
    GEN_VERTEX(pv,rMax*cosPhi,rMax*sinPhi, zMin,1.0,1.0,-sinPhi,+cosPhi,0);
    GEN_VERTEX(pv,rMin*cosPhi,rMin*sinPhi, zMax,1.0,0.0,-sinPhi,+cosPhi,0);
    GEN_VERTEX(pv,rMin*cosPhi,rMin*sinPhi, zMin,0.0,1.0,-sinPhi,+cosPhi,0);
    endShape();
    
    if (drawEdgeLines.getValue()) {
      if (disableLighting) glDisable(GL_LIGHTING);
      if (transparencyOn) glDisable(GL_BLEND);
      
      glBegin(GL_LINES);
      glVertex3f(rMax*cosPhi0,rMax*sinPhi0, zMax);
      glVertex3f(rMax*cosPhi0,rMax*sinPhi0, zMin);
      glVertex3f(rMin*cosPhi0,rMin*sinPhi0, zMax);
      glVertex3f(rMin*cosPhi0,rMin*sinPhi0, zMin);
      glVertex3f(rMax*cosPhi1,rMax*sinPhi1, zMax);
      glVertex3f(rMax*cosPhi1,rMax*sinPhi1, zMin);
      glVertex3f(rMin*cosPhi1,rMin*sinPhi1, zMax);
      glVertex3f(rMin*cosPhi1,rMin*sinPhi1, zMin);
      glEnd();
      if (disableLighting) glEnable(GL_LIGHTING);
      if (transparencyOn) glEnable(GL_BLEND);
    }
    
  }
  //
  // The outer surface at z=+PDZ
  //
  if(rMin==0.F) {
    beginShape(action,TRIANGLE_FAN);
    sinPhi=sinPhi0;
    cosPhi=cosPhi0;
    GEN_VERTEX(pv,0,0,zMax,0.0,0.0,0,0,1);
    for (i = 0; i<=NPHI; i++) {
      GEN_VERTEX(pv,rMax*cosPhi,rMax*sinPhi,zMax,1.0,1.0,0,0,1);
      inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
    }
    endShape();
    //
    // The outer surface at z=-PDZ
    //
    beginShape(action,TRIANGLE_FAN);
    sinPhi=sinPhi0;
    cosPhi=cosPhi0;
    GEN_VERTEX(pv,0,0,zMin,0.0,0.0,0,0,-1);
    for (i = 0; i<=NPHI; i++) {
      GEN_VERTEX(pv,rMax*cosPhi,rMax*sinPhi,zMin,1.0,1.0,0,0,-1);
      inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
    }
    endShape();
    
    
    if (drawEdgeLines.getValue()) {
      if (disableLighting) glDisable(GL_LIGHTING);
      if (transparencyOn) glDisable(GL_BLEND);
      glBegin(GL_LINE_STRIP);      
      sinPhi=sinPhi0;
      cosPhi=cosPhi0;
      if (!noPhiCutout) glVertex3f(0,0,zMax); // only draw if phi range
      for (i = 0; i<=NPHI; i++) {
        glVertex3f(rMax*cosPhi,rMax*sinPhi,zMax);
        inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
      }
      if (!noPhiCutout) glVertex3f(0,0,zMax);
 
      glEnd();
      
      glBegin(GL_LINE_STRIP);      
      sinPhi=sinPhi0;
      cosPhi=cosPhi0;
      if (!noPhiCutout) glVertex3f(0,0,zMin); // only draw if phi range
      for (i = 0; i<=NPHI; i++) {
        glVertex3f(rMax*cosPhi,rMax*sinPhi,zMin);
        inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
      }
      if (!noPhiCutout) glVertex3f(0,0,zMin);
      
      glEnd();
      
      if (disableLighting) glEnable(GL_LIGHTING);
      if (transparencyOn) glEnable(GL_BLEND);
    }
    
  } else {
    beginShape(action,TRIANGLE_STRIP);
    sinPhi=sinPhi0;
    cosPhi=cosPhi0;
    for (i = 0; i<=NPHI; i++) {
      GEN_VERTEX(pv,rMin*cosPhi,rMin*sinPhi,zMax,0.0,0.0,0,0,1);
      GEN_VERTEX(pv,rMax*cosPhi,rMax*sinPhi,zMax,1.0,1.0,0,0,1);
      inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
    }
    endShape();
    //
    // The outer surface at z=-PDZ
    //
    beginShape(action,TRIANGLE_STRIP);
    sinPhi=sinPhi0;
    cosPhi=cosPhi0;
    for (i = 0; i<=NPHI; i++) {
      GEN_VERTEX(pv,rMin*cosPhi,rMin*sinPhi,zMin,0.0,0.0,0,0,-1);
      GEN_VERTEX(pv,rMax*cosPhi,rMax*sinPhi,zMin,1.0,1.0,0,0,-1);
      inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
    }
    endShape();
    
    if (drawEdgeLines.getValue()) {      
      if (disableLighting) glDisable(GL_LIGHTING);
      if (transparencyOn) glDisable(GL_BLEND);
      glBegin(GL_LINE_STRIP);      
      sinPhi=sinPhi0;
      cosPhi=cosPhi0;
      if (!noPhiCutout) glVertex3f(rMin*cosPhi,rMin*sinPhi,zMax); // only draw if phi range
      for (i = 0; i<=NPHI; i++) {
        glVertex3f(rMax*cosPhi,rMax*sinPhi,zMax);
        inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
      }
      if (!noPhiCutout) glVertex3f(rMin*cosPhi1,rMin*sinPhi1,zMax); // only draw if phi range
      glEnd();
      
      glBegin(GL_LINE_STRIP);      
      sinPhi=sinPhi0;
      cosPhi=cosPhi0;
      for (i = 0; i<=NPHI; i++) {
        glVertex3f(rMin*cosPhi,rMin*sinPhi,zMax);
        inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
      }
      glEnd();
      
      glBegin(GL_LINE_STRIP);      
      sinPhi=sinPhi0;
      cosPhi=cosPhi0;
      if (!noPhiCutout) glVertex3f(rMin*cosPhi,rMin*sinPhi,zMin); // only draw if phi range
      for (i = 0; i<=NPHI; i++) {
        glVertex3f(rMax*cosPhi,rMax*sinPhi,zMin);
        inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
      }
      if (!noPhiCutout) glVertex3f(rMin*cosPhi1,rMin*sinPhi1,zMin); // only draw if phi range
      glEnd();
      
      glBegin(GL_LINE_STRIP);      
      sinPhi=sinPhi0;
      cosPhi=cosPhi0;
      for (i = 0; i<=NPHI; i++) {
        glVertex3f(rMin*cosPhi,rMin*sinPhi,zMin);
        inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
      }
      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
  }
}

getChildren()

SoChildList * SoTubs::getChildren ( ) const

protectedvirtual

GetChildList, required whenever the class has hidden children.

Definition at line 349 of file SoTubs.cxx.

                                       {
  return m_children.get();
}

inc()

void SoTubs::inc ( double &  sinPhi, double &  cosPhi, double  sinDeltaPhi, double  cosDeltaPhi  ) const

inlineprivate

help with trigonometry. increments sines an cosines by an angle.

Definition at line 154 of file SoTubs.h.

                                                                                           {
    double oldSin=sinPhi,oldCos=cosPhi;
    sinPhi = oldSin*cosDeltaPhi+oldCos*sinDeltaPhi;
    cosPhi = oldCos*cosDeltaPhi-oldSin*sinDeltaPhi;
  }

initClass()

void SoTubs::initClass ( )

static

Class Initializer, required.

Definition at line 63 of file SoTubs.cxx.

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

SO_NODE_HEADER()

SoTubs::SO_NODE_HEADER ( SoTubs  )

private

updateChildren()

void SoTubs::updateChildren ( )

private

Used to modify hidden children when a data field is changed.

Required whenever the class has hidden children.

Definition at line 364 of file SoTubs.cxx.

                            {
 
  // Redraw the G4Tubs....
 
  assert(m_children->getLength()==1);
  SoSeparator       *sep                = (SoSeparator *)  ( *m_children)[0];
  SoCoordinate3     *theCoordinates     = (SoCoordinate3 *)      ( sep->getChild(0));
  SoNormal          *theNormals         = (SoNormal *)           ( sep->getChild(1));
  SoNormalBinding   *theNormalBinding   = (SoNormalBinding *)    ( sep->getChild(2));
  SoIndexedFaceSet  *theFaceSet         = (SoIndexedFaceSet *)   ( sep->getChild(3));
 
 
  const int NPHI=96, NPOINTS=2*(2*NPHI+2), NFACES=4*NPHI+2, NINDICES = NFACES*5;
  float points[NPOINTS][3],normals[NFACES][3];
#ifdef INVENTOR2_0
  static long     indices[NINDICES];
#else
  static int32_t  indices[NINDICES];
#endif
 
  static int init=0;
  double phi, pp, DeltaPhi;
 
  // Indices need to be generated once! This is here to keep it close to the point
  // generation, since otherwise it will be confusing.
 
  int i;
  if (!init) {
    init = 1;
    // Outer face
    for (i = 0; i< NPHI; i++) {
      // 0 1 3 2;
      indices[5*i+0] =  2*i+0;
      indices[5*i+1] =  2*i+1;
      indices[5*i+2] =  2*i+3;
      indices[5*i+3] =  2*i+2;
      indices[5*i+4] = SO_END_FACE_INDEX;
    }
    // the inner face
    for (i=0;i<NPHI;i++) {
      indices[5*1*NPHI + 5*i+0] = 2*NPHI+2 + 2*i+0;
      indices[5*1*NPHI + 5*i+1] = 2*NPHI+2 + 2*i+1;
      indices[5*1*NPHI + 5*i+2] = 2*NPHI+2 + 2*i+3;
      indices[5*1*NPHI + 5*i+3] = 2*NPHI+2 + 2*i+2;
      indices[5*1*NPHI + 5*i+4] = SO_END_FACE_INDEX;
    }
    // the top side
    for (i=0;i<NPHI;i++) {
      indices[5*2*NPHI + 5*i+0] = 2*i+0;
      indices[5*2*NPHI + 5*i+1] = 2*i+2;
      indices[5*2*NPHI + 5*i+2] = NPOINTS - (2*i+4);
      indices[5*2*NPHI + 5*i+3] = NPOINTS - (2*i+2);
      indices[5*2*NPHI + 5*i+4] = SO_END_FACE_INDEX;
    }
    // the bottom side
    for (i=0;i<NPHI;i++) {
      indices[5*3*NPHI + 5*i+0] = 2*i+1;
      indices[5*3*NPHI + 5*i+1] = NPOINTS - (2*i+1);
      indices[5*3*NPHI + 5*i+2] = NPOINTS - (2*i+3);
      indices[5*3*NPHI + 5*i+3] = 2*i+3;
      indices[5*3*NPHI + 5*i+4] = SO_END_FACE_INDEX;
    }
    // the odd side
    indices[5*4*NPHI +0] = 2*NPHI;
    indices[5*4*NPHI +1] = 2*NPHI+1;
    indices[5*4*NPHI +2] = 2*NPHI+3;
    indices[5*4*NPHI +3] = 2*NPHI+2;
    indices[5*4*NPHI +4] = SO_END_FACE_INDEX;
    // aother odd side
    indices[5*4*NPHI +5 +0] = 0;
    indices[5*4*NPHI +5 +1] = NPOINTS-2;
    indices[5*4*NPHI +5 +2] = NPOINTS-1;
    indices[5*4*NPHI +5 +3] = 1;
    indices[5*4*NPHI +5 +4] = SO_END_FACE_INDEX;
  }
  // Points need to be generated each time:
  if (pDPhi.getValue()<2*M_PI) {
    // the odd side
    indices[5*4*NPHI +0] = 2*NPHI;
    indices[5*4*NPHI +1] = 2*NPHI+1;
    indices[5*4*NPHI +2] = 2*NPHI+3;
    indices[5*4*NPHI +3] = 2*NPHI+2;
    indices[5*4*NPHI +4] = SO_END_FACE_INDEX;
    // aother odd side
    indices[5*4*NPHI +5 +0] = 0;
    indices[5*4*NPHI +5 +1] = NPOINTS-2;
    indices[5*4*NPHI +5 +2] = NPOINTS-1;
    indices[5*4*NPHI +5 +3] = 1;
    indices[5*4*NPHI +5 +4] = SO_END_FACE_INDEX;
  }
  else {
    // the odd side
    indices[5*4*NPHI +0] = SO_END_FACE_INDEX;
    indices[5*4*NPHI +1] = SO_END_FACE_INDEX;
    indices[5*4*NPHI +2] = SO_END_FACE_INDEX;
    indices[5*4*NPHI +3] = SO_END_FACE_INDEX;
    indices[5*4*NPHI +4] = SO_END_FACE_INDEX;
    // aother odd side
    indices[5*4*NPHI +5 +0] = SO_END_FACE_INDEX;
    indices[5*4*NPHI +5 +1] = SO_END_FACE_INDEX;
    indices[5*4*NPHI +5 +2] = SO_END_FACE_INDEX;
    indices[5*4*NPHI +5 +3] = SO_END_FACE_INDEX;
    indices[5*4*NPHI +5 +4] = SO_END_FACE_INDEX;
  }
  // The outer surface
  DeltaPhi = pDPhi.getValue()/NPHI, phi = pSPhi.getValue();
  for (i = 0; i<=NPHI; i++) {
    points[2*i+0][0] = pRMax.getValue()*FCOS(phi);
    points[2*i+0][1]= pRMax.getValue()*FSIN(phi);
    points[2*i+0][2] = +pDz.getValue();
 
    points[2*i+1][0] = pRMax.getValue()*FCOS(phi);
    points[2*i+1][1]= pRMax.getValue()*FSIN(phi);
    points[2*i+1][2] = -pDz.getValue();
 
    pp = phi+DeltaPhi/2.0;
    if (i!=NPHI) {
      normals[i][0] = FCOS(pp);
      normals[i][1] = FSIN(pp);
      normals[i][2] = 0;
    }
    phi+=DeltaPhi;
  }
  // The inner surface
  phi = pSPhi.getValue() + pDPhi.getValue();
  for (i = 0; i<=NPHI; i++) {
    points[2*NPHI+2+2*i+0][0] = pRMin.getValue()*FCOS(phi);
    points[2*NPHI+2+2*i+0][1] = pRMin.getValue()*FSIN(phi);
    points[2*NPHI+2+2*i+0][2] = +pDz.getValue();
    points[2*NPHI+2+2*i+1][0] = pRMin.getValue()*FCOS(phi);
    points[2*NPHI+2+2*i+1][1] = pRMin.getValue()*FSIN(phi);
    points[2*NPHI+2+2*i+1][2] = -pDz.getValue();
    pp = phi-DeltaPhi/2.0;
    if (i!=NPHI) {
      normals[NPHI+i][0] = -FCOS(pp);
      normals[NPHI+i][1] = -FSIN(pp);
      normals[NPHI+i][2] = 0;
    }
    phi-=DeltaPhi;
  }
  // The top side
  for (i=0;i<NPHI;i++) {
    normals[2*NPHI+i][0]=normals[2*NPHI+i][1]=0;
    normals[2*NPHI+i][2]=  1.0;
  }
  // The bottom side
  for (i=0;i<NPHI;i++) {
    normals[3*NPHI+i][0]=normals[3*NPHI+i][1]=0;
    normals[3*NPHI+i][2]= -1.0;
  }
  // The odd side
  phi = pSPhi.getValue();
  normals[4*NPHI+0][0]=  FSIN(phi);
  normals[4*NPHI+0][1]= -FCOS(phi);
  normals[4*NPHI+0][2]=0;
 
    // Another odd side
  phi = pSPhi.getValue()+pDPhi.getValue();
  normals[4*NPHI+1][0]= -FSIN(phi);
  normals[4*NPHI+1][1]= +FCOS(phi);
  normals[4*NPHI+1][2]=0;
 
  for (int np=0;np<NPOINTS; np++) theCoordinates->point.set1Value(np,points[np][0],points[np][1],points[np][2]);
  for (int ni=0;ni<NINDICES;ni++) theFaceSet->coordIndex.set1Value(ni,indices[ni]);
  for (int nf=0;nf<NFACES;nf++) theNormals->vector.set1Value(nf,normals[nf][0],normals[nf][1],normals[nf][2]);
  theNormalBinding->value=SoNormalBinding::PER_FACE;
}

Member Data Documentation

alternateRep

SoSFNode SoTubs::alternateRep

Alternate rep - required.

Definition at line 87 of file SoTubs.h.

drawEdgeLines

SoSFBool SoTubs::drawEdgeLines

Definition at line 89 of file SoTubs.h.

m_children

std::unique_ptr<SoChildList> SoTubs::m_children

private

ChildList. Required whenever the class has hidden children.

Definition at line 149 of file SoTubs.h.

pDPhi

SoSFFloat SoTubs::pDPhi

Delta-angle, in radians.

Definition at line 78 of file SoTubs.h.

pDz

SoSFFloat SoTubs::pDz

Half-length in Z.

Definition at line 70 of file SoTubs.h.

pOverrideNPhi

SoSFInt32 SoTubs::pOverrideNPhi

Override number of phi subdivision used for rendering shape (i.e.

ignore e.g. complexity value). Put field to 0 (the default) to ignore it.

Definition at line 83 of file SoTubs.h.

pRMax

SoSFFloat SoTubs::pRMax

Outside radius of the tube.

Definition at line 66 of file SoTubs.h.

pRMin

SoSFFloat SoTubs::pRMin

Inside radius of the tube.

Definition at line 62 of file SoTubs.h.

pSPhi

SoSFFloat SoTubs::pSPhi

Starting angle, in radians.

Definition at line 74 of file SoTubs.h.

---

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

• SoTubs.h
• SoTubs.cxx