#include <Geant4_SoPolyhedron.h>

Inheritance diagram for Geant4_SoPolyhedron:

Public Member Functions
virtual void	clearAlternateRep ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

	Geant4_SoPolyhedron ()

	Geant4_SoPolyhedron (const G4Polyhedron &)

	Geant4_SoPolyhedron (G4Polyhedron *)

virtual void	generateAlternateRep ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

Static Public Member Functions
static void	initClass ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

Data Fields
SoSFNode	alternateRep

SoSFBool	reducedWireFrame

SoSFBool	solid

Protected Member Functions
virtual void	computeBBox (SoAction *, SbBox3f &, SbVec3f &)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

virtual void	doAction (SoAction *)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

virtual void	generatePrimitives (SoAction *)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

virtual	~Geant4_SoPolyhedron ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// More...

Private Member Functions
	Geant4_SoPolyhedron (const Geant4_SoPolyhedron &)

Geant4_SoPolyhedron &	operator= (const Geant4_SoPolyhedron &)

	SO_NODE_HEADER (Geant4_SoPolyhedron)

Private Attributes
G4Polyhedron *	fPolyhedron

Detailed Description

SoPolyhedron is an Inventor encapsulation of the G4Polyedron class written by E.Chernyaev. In particular SoPolyhedron permits to represent boolean operations over solids. To avoid clashes with other libraries (Geant4) where the G4Polyhedron classes may be found, the G4Polyhedron (through usage of CPP macros) had been renamed G4Polyhedron in the HEPVis lib. The solids are modeled with G4Polyedron objects. The G4Polyhedron permits to produce a new G4Polyhedron according to the boolean operation done on them. The resulting G4Polyhedron is then given to an SoPolyhedron for rendering. Note that a boolean operation could be rendered in wire frame by drawing the contour of the resulting solid (not by drawing the wire frame of a triangulation). See the applications/Polyhedron example.

Definition at line 54 of file Geant4_SoPolyhedron.h.

Constructor & Destructor Documentation

◆ Geant4_SoPolyhedron() [1/4]

Geant4_SoPolyhedron::Geant4_SoPolyhedron ( const Geant4_SoPolyhedron & )

private

◆ Geant4_SoPolyhedron() [2/4]

Geant4_SoPolyhedron::Geant4_SoPolyhedron ( )

Definition at line 71 of file SoPolyhedron.cc.

:fPolyhedron(0)
{
  SO_NODE_CONSTRUCTOR(Geant4_SoPolyhedron);
  SO_NODE_ADD_FIELD(solid,(TRUE));
  SO_NODE_ADD_FIELD(reducedWireFrame,(TRUE));
  SO_NODE_ADD_FIELD(alternateRep,(NULL));
}

References alternateRep, reducedWireFrame, solid, and TRUE.

◆ Geant4_SoPolyhedron() [3/4]

Geant4_SoPolyhedron::Geant4_SoPolyhedron ( const G4Polyhedron & aPolyhedron )

Definition at line 83 of file SoPolyhedron.cc.

:fPolyhedron(0)
{
  SO_NODE_CONSTRUCTOR(Geant4_SoPolyhedron);
  SO_NODE_ADD_FIELD(solid,(TRUE));
  SO_NODE_ADD_FIELD(reducedWireFrame,(TRUE));
  SO_NODE_ADD_FIELD(alternateRep,(NULL));
 
  fPolyhedron = new G4Polyhedron(aPolyhedron);
}

References alternateRep, fPolyhedron, reducedWireFrame, solid, and TRUE.

◆ Geant4_SoPolyhedron() [4/4]

Geant4_SoPolyhedron::Geant4_SoPolyhedron ( G4Polyhedron * aPolyhedron )

Definition at line 98 of file SoPolyhedron.cc.

:fPolyhedron(aPolyhedron)
{
  SO_NODE_CONSTRUCTOR(Geant4_SoPolyhedron);
  SO_NODE_ADD_FIELD(solid,(TRUE));
  SO_NODE_ADD_FIELD(reducedWireFrame,(TRUE));
  SO_NODE_ADD_FIELD(alternateRep,(NULL));
}

References alternateRep, reducedWireFrame, solid, and TRUE.

◆ ~Geant4_SoPolyhedron()

Geant4_SoPolyhedron::~Geant4_SoPolyhedron ( )

protectedvirtual

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 111 of file SoPolyhedron.cc.

{
  delete fPolyhedron;
}

References fPolyhedron.

Member Function Documentation

◆ clearAlternateRep()

void Geant4_SoPolyhedron::clearAlternateRep ( )

virtual

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 539 of file SoPolyhedron.cc.

{
  alternateRep.setValue(NULL);
}

References alternateRep.

◆ computeBBox()

void Geant4_SoPolyhedron::computeBBox	(	SoAction *	,
		SbBox3f &	aBox,
		SbVec3f &	aCenter
	)

protectedvirtual

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 252 of file SoPolyhedron.cc.

{
  if(!fPolyhedron) return;
  if(fPolyhedron->GetNoFacets()<=0) { // Abnormal polyhedron.
    SbVec3f vmin(-1,-1,-1);
    SbVec3f vmax( 1, 1, 1);
    aBox.setBounds(vmin,vmax);
    aCenter.setValue(0,0,0);
  } else {
    SbBool first = TRUE;
    float xmn = 0,ymn = 0,zmn = 0;
    float xmx = 0,ymx = 0,zmx = 0;
    float xct = 0,yct = 0,zct = 0;
    SbVec3f point;
    int count = 0;
    // Assume all facets are convex quadrilaterals :
    bool notLastFace;
    do {
      HVNormal3D unitNormal;
      notLastFace = fPolyhedron->GetNextUnitNormal(unitNormal);
      bool notLastEdge;
      do {
        HVPoint3D vertex;
        int edgeFlag = 1;
        notLastEdge = fPolyhedron->GetNextVertex(vertex,edgeFlag);
        point.setValue(vertex[0],vertex[1],vertex[2]);
        if(first==TRUE) {
          xct = xmx = xmn = point[0];
          yct = ymx = ymn = point[1];
          zct = zmx = zmn = point[2];
          count++;
          first = FALSE;
        } else {
          xmn = SbMinimum(xmn,point[0]);
          ymn = SbMinimum(ymn,point[1]);
          zmn = SbMinimum(zmn,point[2]);
          //
          xmx = SbMaximum(xmx,point[0]);
          ymx = SbMaximum(ymx,point[1]);
          zmx = SbMaximum(zmx,point[2]);
          //
          xct += point[0];
          yct += point[1];
          zct += point[2];
          count++;
        }
        //
      } while (notLastEdge);
    } while (notLastFace);
    SbVec3f vmin(xmn,ymn,zmn);
    SbVec3f vmax(xmx,ymx,zmx);
    aBox.setBounds(vmin,vmax);
    if(count==0)
      aCenter.setValue(0,0,0);
    else
      aCenter.setValue(xct/count,yct/count,zct/count);
  }
}

References FALSE, fPolyhedron, HepPolyhedron::GetNextUnitNormal(), HepPolyhedron::GetNextVertex(), HepPolyhedron::GetNoFacets(), SbMaximum, SbMinimum, and TRUE.

◆ doAction()

void Geant4_SoPolyhedron::doAction ( SoAction * aAction )

protectedvirtual

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 547 of file SoPolyhedron.cc.

{
  SO_ALTERNATEREP_DO_ACTION(aAction)
  SoShape::doAction(aAction);
}

References SO_ALTERNATEREP_DO_ACTION.

◆ generateAlternateRep()

void Geant4_SoPolyhedron::generateAlternateRep ( )

virtual

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 323 of file SoPolyhedron.cc.

{
  if(!fPolyhedron) return;
  if(fPolyhedron->GetNoFacets()<=0) return; // Abnormal polyhedron.
  if(fPolyhedron->GetNoVertices()<=0) return; // Abnormal polyhedron.
 
  if(solid.getValue()==TRUE) {
 
    SoSeparator* separator = new SoSeparator;
 
    SoNormalBinding* normalBinding = new SoNormalBinding;
    normalBinding->value = SoNormalBinding::PER_FACE;
    separator->addChild(normalBinding);
 
    SoCoordinate3* coordinate3 = new SoCoordinate3;
    separator->addChild(coordinate3);
    SoNormal* normal = new SoNormal;
    separator->addChild(normal);
    SoIndexedFaceSet* indexedFaceSet = new SoIndexedFaceSet;
    separator->addChild(indexedFaceSet);
 
    int nvert = fPolyhedron->GetNoVertices();
    int nface = fPolyhedron->GetNoFacets();
 
    SbVec3f* normals = new SbVec3f[nface];
    //FIXME : have the exact booking.
    SbVec3f* points = new SbVec3f[nvert];
    int32_t* coords = new int32_t[nvert+1];
 
    int inormal = 0;
    int icoord = 0;
    int iindex = 0;
 
    // Assume all facets are convex quadrilaterals :
    bool notLastFace;
    do {
      HVNormal3D unitNormal;
      notLastFace = fPolyhedron->GetNextUnitNormal(unitNormal);
 
      // begin face POLYGON
      int ipoint = 0;
 
      bool notLastEdge;
      int edgeFlag = 1;
      do {
        HVPoint3D vertex;
        notLastEdge = fPolyhedron->GetNextVertex(vertex,edgeFlag);
        points[ipoint].setValue(vertex[0],vertex[1],vertex[2]);
        coords[ipoint] = icoord + ipoint;
        ipoint++;
      } while (notLastEdge);
 
      // end face.
      coords[ipoint] = SO_END_FACE_INDEX;
      coordinate3->point.setValues(icoord,ipoint,points);
      icoord += ipoint;
 
      normals[inormal].setValue(unitNormal[0],unitNormal[1],unitNormal[2]);
      inormal++;  
 
      indexedFaceSet->coordIndex.setValues(iindex,(ipoint+1),coords);
      iindex += ipoint+1;
 
    } while (notLastFace);
 
    normal->vector.setValues(0,inormal,normals);
 
    delete [] normals;
    delete [] coords;
    delete [] points;
 
    alternateRep.setValue(separator);
 
  } else {
 
    SoSeparator* separator = new SoSeparator;
 
    int nvert = fPolyhedron->GetNoVertices();
 
    //FIXME : have the exact booking.
    int nedge = nvert * 3;
    int npoint = nedge*2;
    SbVec3f* points = new SbVec3f[npoint];
    int ncoord = nedge*3;
    int32_t* coords = new int32_t[ncoord];
 
    SbVec3f pvb(0.,0.,0.), pve(0.,0.,0.);
 
    SbBool empty = TRUE;
    int ipoint = 0;
    int icoord = 0;
 
    bool notLastFace;
    do {
      HVNormal3D unitNormal;
      notLastFace = fPolyhedron->GetNextUnitNormal(unitNormal);
 
      //SbVec3f normal;
      //if( (fProjection==SbProjectionRZ) || (fProjection==SbProjectionZR) ) {
        //normal.setValue(0,0,1);
      //} else {
        //normal.setValue(unitNormal[0],unitNormal[1],unitNormal[2]);
      //}
 
      // Treat edges :
      int edgeFlag = 1;
      int prevEdgeFlag = edgeFlag;
      bool notLastEdge;
      SbBool firstEdge = TRUE;
      do {
        HVPoint3D vertex;
        notLastEdge = fPolyhedron->GetNextVertex(vertex,edgeFlag);
        if(reducedWireFrame.getValue()==FALSE) edgeFlag = 1;        
        if(firstEdge) {
          if(edgeFlag > 0) {
            pvb.setValue(vertex[0],vertex[1],vertex[2]);
          } else {
          }
          firstEdge = FALSE;
          prevEdgeFlag = edgeFlag;
        } else {
          if(edgeFlag!=prevEdgeFlag) { 
            if(edgeFlag > 0) { // Pass to a visible edge :
              pvb.setValue(vertex[0],vertex[1],vertex[2]);
            } else { // Pass to an invisible edge :
              pve.setValue(vertex[0],vertex[1],vertex[2]);
 
              if((ipoint+1)>=npoint) {
                int new_npoint = 2 * npoint;
                SbVec3f* new_points = new SbVec3f[new_npoint];
                for(int i=0;i<npoint;i++) new_points[i] = points[i];
                delete [] points;
                npoint = new_npoint;
                points = new_points;
              }
 
              if((icoord+2)>=ncoord) {
                int new_ncoord = 2 * ncoord;
                int32_t* new_coords = new int32_t[new_ncoord];
                for(int i=0;i<ncoord;i++) new_coords[i] = coords[i];
                delete [] coords;
                ncoord = new_ncoord;
                coords = new_coords;
              }
 
              points[ipoint+0] = pvb;
              points[ipoint+1] = pve;
              coords[icoord+0] = ipoint + 0;
              coords[icoord+1] = ipoint + 1;
              coords[icoord+2] = SO_END_LINE_INDEX;
              ipoint += 2;
              icoord += 3;
              empty = FALSE;
            }
            prevEdgeFlag = edgeFlag;
          } else {
            if(edgeFlag > 0) {
              pve.setValue(vertex[0],vertex[1],vertex[2]);
 
              if((ipoint+1)>=npoint) {
                int new_npoint = 2 * npoint;
                SbVec3f* new_points = new SbVec3f[new_npoint];
                for(int i=0;i<npoint;i++) new_points[i] = points[i];
                delete [] points;
                npoint = new_npoint;
                points = new_points;
              }
 
              if((icoord+2)>=ncoord) {
                int new_ncoord = 2 * ncoord;
                int32_t* new_coords = new int32_t[new_ncoord];
                for(int i=0;i<ncoord;i++) new_coords[i] = coords[i];
                delete [] coords;
                ncoord = new_ncoord;
                coords = new_coords;
              }
 
              points[ipoint+0] = pvb;
              points[ipoint+1] = pve;
              coords[icoord+0] = ipoint + 0;
              coords[icoord+1] = ipoint + 1;
              coords[icoord+2] = SO_END_LINE_INDEX;
              ipoint += 2;
              icoord += 3;
              empty = FALSE;
 
              pvb = pve;
            } else {
            }
          }
        }
      } while (notLastEdge);
    } while (notLastFace);
 
    SoCoordinate3* coordinate3 = new SoCoordinate3;
    coordinate3->point.setValues(0,ipoint,points);
    separator->addChild(coordinate3);
 
    SoIndexedLineSet* indexedLineSet = new SoIndexedLineSet;
    indexedLineSet->coordIndex.setValues(0,icoord,coords);
    separator->addChild(indexedLineSet);
 
    delete [] coords;
    delete [] points;
 
    if(empty==TRUE) {
      separator->unref();
    } else {
      alternateRep.setValue(separator);
    }
  }
}

References alternateRep, anonymous_namespace{G4MTcoutDestination.cc}::empty, FALSE, fPolyhedron, HepPolyhedron::GetNextUnitNormal(), HepPolyhedron::GetNextVertex(), HepPolyhedron::GetNoFacets(), HepPolyhedron::GetNoVertices(), CLHEP::normal(), reducedWireFrame, solid, and TRUE.

◆ generatePrimitives()

void Geant4_SoPolyhedron::generatePrimitives ( SoAction * aAction )

protectedvirtual

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 119 of file SoPolyhedron.cc.

{
  if(!fPolyhedron) return;
  if(fPolyhedron->GetNoFacets()<=0) return; // Abnormal polyhedron.
 
  SoState *state = aAction->getState();
  SbBool useTexFunction =
    (SoTextureCoordinateElement::getType(state) == 
     SoTextureCoordinateElement::FUNCTION);
  const SoTextureCoordinateElement *tce = NULL;
  SbVec4f texCoord(0.,0.,0.,0.);
  if (useTexFunction) {
    tce = SoTextureCoordinateElement::getInstance(state);
  } else {
    texCoord[2] = 0.0;
    texCoord[3] = 1.0;
  }
 
  if(solid.getValue()==TRUE) {
    SoPrimitiveVertex pv;
    SbVec3f point, normal;
    //----------------------------------------
#define GEN_VERTEX(pv,x,y,z,s,t,nx,ny,nz)  \
  point.setValue(x,y,z);                   \
  normal.setValue(nx,ny,nz);               \
  if (useTexFunction) {                    \
    texCoord=tce->get(point,normal);       \
  } else {                                 \
    texCoord[0]=s;                         \
    texCoord[1]=t;                         \
  }                                        \
  pv.setPoint(point);                      \
  pv.setNormal(normal);                    \
  pv.setTextureCoords(texCoord);           \
  shapeVertex(&pv);
  //----------------------------------------
 
    // Assume all facets are convex quadrilaterals :
    bool notLastFace;
    do {
      HVNormal3D unitNormal;
      notLastFace = fPolyhedron->GetNextUnitNormal(unitNormal);
 
      beginShape(aAction,POLYGON);
      bool notLastEdge;
      int edgeFlag = 1;
      do {
        HVPoint3D vertex;
        notLastEdge = fPolyhedron->GetNextVertex(vertex,edgeFlag);
        GEN_VERTEX(pv,
                   vertex[0],
                   vertex[1],
                   vertex[2],
                   0.0,0.0,
                   unitNormal[0],
                   unitNormal[1],
                   unitNormal[2]);
      } while (notLastEdge);
      endShape();
    } while (notLastFace);
  } else {
    SoPrimitiveVertex pvb,pve;
    pve.setTextureCoords(texCoord);
    pvb.setTextureCoords(texCoord);
 
#ifdef __COIN__ // To bypass a bug in invokeLineSegment when picking.
    beginShape(aAction,POLYGON);
    endShape();
#endif
 
    SbVec3f point;
    bool notLastFace;
    do {
      HVNormal3D unitNormal;
      notLastFace = fPolyhedron->GetNextUnitNormal(unitNormal);
 
      SbVec3f normal;
      normal.setValue(unitNormal[0],unitNormal[1],unitNormal[2]);
 
      // Treat edges :
      int edgeFlag = 1;
      int prevEdgeFlag = edgeFlag;
      bool notLastEdge;
      SbBool firstEdge = TRUE;
      do {
        HVPoint3D vertex;
        notLastEdge = fPolyhedron->GetNextVertex(vertex,edgeFlag);
        if(reducedWireFrame.getValue()==FALSE) edgeFlag = 1;        
        if(firstEdge) {
          if(edgeFlag > 0) {
            pvb.setNormal(normal);
            point.setValue(vertex[0],vertex[1],vertex[2]);
            pvb.setPoint(point);
          } else {
          }
          firstEdge = FALSE;
          prevEdgeFlag = edgeFlag;
        } else {
          if(edgeFlag!=prevEdgeFlag) { 
            if(edgeFlag > 0) { // Pass to a visible edge :
              pvb.setNormal(normal);
              point.setValue(vertex[0],vertex[1],vertex[2]);
              pvb.setPoint(point);
            } else { // Pass to an invisible edge :
              pve.setNormal(normal);
              point.setValue(vertex[0],vertex[1],vertex[2]);
              pve.setPoint(point);
              invokeLineSegmentCallbacks(aAction,&pvb,&pve);
            }
            prevEdgeFlag = edgeFlag;
          } else {
            if(edgeFlag > 0) {
              pve.setNormal(normal);
              point.setValue(vertex[0],vertex[1],vertex[2]);
              pve.setPoint(point);
              invokeLineSegmentCallbacks(aAction,&pvb,&pve);
              pvb = pve;
            } else {
            }
          }
        }
      } while (notLastEdge);
    } while (notLastFace);
  }
 
}

References FALSE, fPolyhedron, GEN_VERTEX, HepPolyhedron::GetNextUnitNormal(), HepPolyhedron::GetNextVertex(), HepPolyhedron::GetNoFacets(), CLHEP::normal(), reducedWireFrame, solid, and TRUE.

◆ initClass()

void Geant4_SoPolyhedron::initClass ( )

static

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 59 of file SoPolyhedron.cc.

{
  static bool first = true;
  if (first) {
    first = false;
    SO_NODE_INIT_CLASS(Geant4_SoPolyhedron,SoShape,"Shape");
  }
}

Referenced by G4OpenInventor::InitNodes().

◆ operator=()

Geant4_SoPolyhedron & Geant4_SoPolyhedron::operator= ( const Geant4_SoPolyhedron & )

private

◆ SO_NODE_HEADER()

Geant4_SoPolyhedron::SO_NODE_HEADER ( Geant4_SoPolyhedron )

private

Field Documentation

◆ alternateRep

SoSFNode Geant4_SoPolyhedron::alternateRep

Definition at line 62 of file Geant4_SoPolyhedron.h.

Referenced by clearAlternateRep(), Geant4_SoPolyhedron(), and generateAlternateRep().

◆ fPolyhedron

G4Polyhedron* Geant4_SoPolyhedron::fPolyhedron

private

Definition at line 78 of file Geant4_SoPolyhedron.h.

Referenced by computeBBox(), Geant4_SoPolyhedron(), generateAlternateRep(), generatePrimitives(), and ~Geant4_SoPolyhedron().

◆ reducedWireFrame

SoSFBool Geant4_SoPolyhedron::reducedWireFrame

Definition at line 61 of file Geant4_SoPolyhedron.h.

Referenced by G4OpenInventorSceneHandler::AddPrimitive(), Geant4_SoPolyhedron(), generateAlternateRep(), and generatePrimitives().

◆ solid

SoSFBool Geant4_SoPolyhedron::solid

Definition at line 60 of file Geant4_SoPolyhedron.h.

Referenced by G4OpenInventorSceneHandler::AddPrimitive(), demo.App::cmd_beamOn(), Lesson1.App::cmd_beamOn(), Geant4_SoPolyhedron(), generateAlternateRep(), and generatePrimitives().

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

source/visualization/OpenInventor/include/Geant4_SoPolyhedron.h
source/visualization/OpenInventor/src/SoPolyhedron.cc

Public Member Functions

Static Public Member Functions

Data Fields

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Geant4_SoPolyhedron() [1/4]

◆ Geant4_SoPolyhedron() [2/4]

◆ Geant4_SoPolyhedron() [3/4]

◆ Geant4_SoPolyhedron() [4/4]

◆ ~Geant4_SoPolyhedron()

Member Function Documentation

◆ clearAlternateRep()

◆ computeBBox()

◆ doAction()

◆ generateAlternateRep()

◆ generatePrimitives()

◆ initClass()

◆ operator=()

◆ SO_NODE_HEADER()

Field Documentation

◆ alternateRep

◆ fPolyhedron

◆ reducedWireFrame

◆ solid