Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4OpenGLSceneHandler Class Reference

#include <G4OpenGLSceneHandler.hh>

+ Inheritance diagram for G4OpenGLSceneHandler:

Public Types

enum  FlushAction {
  endOfEvent , endOfRun , eachPrimitive , NthPrimitive ,
  NthEvent , never
}
 
- Public Types inherited from G4VSceneHandler
enum  MarkerSizeType { world , screen }
 

Public Member Functions

virtual void BeginPrimitives (const G4Transform3D &objectTransformation)
 
virtual void EndPrimitives ()
 
virtual void BeginPrimitives2D (const G4Transform3D &objectTransformation)
 
virtual void EndPrimitives2D ()
 
void AddPrimitive (const G4Polyline &)
 
void AddPrimitive (const G4Polymarker &)
 
void AddPrimitive (const G4Text &)
 
void AddPrimitive (const G4Circle &)
 
void AddPrimitive (const G4Square &)
 
void AddPrimitivesCircle (const std::vector< G4VMarker > &)
 
void AddPrimitivesSquare (const std::vector< G4VMarker > &)
 
void AddPrimitive (const G4Polyhedron &)
 
void PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &)
 
void AddSolid (const G4Box &)
 
void AddSolid (const G4Cons &)
 
void AddSolid (const G4Tubs &)
 
void AddSolid (const G4Trd &)
 
void AddSolid (const G4Trap &)
 
void AddSolid (const G4Sphere &)
 
void AddSolid (const G4Para &)
 
void AddSolid (const G4Torus &)
 
void AddSolid (const G4Polycone &)
 
void AddSolid (const G4Polyhedra &)
 
void AddSolid (const G4Orb &)
 
void AddSolid (const G4Ellipsoid &)
 
void AddSolid (const G4TessellatedSolid &)
 
void AddSolid (const G4VSolid &)
 
void AddCompound (const G4VTrajectory &)
 
void AddCompound (const G4VHit &)
 
void AddCompound (const G4VDigi &)
 
void AddCompound (const G4THitsMap< G4double > &)
 
void AddCompound (const G4THitsMap< G4StatDouble > &)
 
void AddCompound (const G4Mesh &)
 
virtual void AddPrimitive (const G4Plotter &)
 
- Public Member Functions inherited from G4VSceneHandler
 G4VSceneHandler (G4VGraphicsSystem &system, G4int id, const G4String &name="")
 
virtual ~G4VSceneHandler ()
 
virtual void PostAddSolid ()
 
virtual void BeginModeling ()
 
virtual void EndModeling ()
 
virtual const G4VisExtentGetExtent () const
 
const G4StringGetName () const
 
G4int GetSceneHandlerId () const
 
G4int GetViewCount () const
 
G4VGraphicsSystemGetGraphicsSystem () const
 
G4SceneGetScene () const
 
const G4ViewerListGetViewerList () const
 
G4VModelGetModel () const
 
G4VViewerGetCurrentViewer () const
 
G4bool GetMarkForClearingTransientStore () const
 
G4bool IsReadyForTransients () const
 
G4bool GetTransientsDrawnThisEvent () const
 
G4bool GetTransientsDrawnThisRun () const
 
const G4Transform3DGetObjectTransformation () const
 
void SetName (const G4String &)
 
void SetCurrentViewer (G4VViewer *)
 
virtual void SetScene (G4Scene *)
 
G4ViewerListSetViewerList ()
 
void SetModel (G4VModel *)
 
void SetMarkForClearingTransientStore (G4bool)
 
void SetTransientsDrawnThisEvent (G4bool)
 
void SetTransientsDrawnThisRun (G4bool)
 
void SetObjectTransformation (const G4Transform3D &)
 
const G4ColourGetColour ()
 
const G4ColourGetColor ()
 
const G4ColourGetColour (const G4Visible &)
 
const G4ColourGetColor (const G4Visible &)
 
const G4ColourGetTextColour (const G4Text &)
 
const G4ColourGetTextColor (const G4Text &)
 
G4double GetLineWidth (const G4VisAttributes *)
 
G4ViewParameters::DrawingStyle GetDrawingStyle (const G4VisAttributes *)
 
G4int GetNumberOfCloudPoints (const G4VisAttributes *) const
 
G4bool GetAuxEdgeVisible (const G4VisAttributes *)
 
G4int GetNoOfSides (const G4VisAttributes *)
 
G4double GetMarkerSize (const G4VMarker &, MarkerSizeType &)
 
G4double GetMarkerDiameter (const G4VMarker &, MarkerSizeType &)
 
G4double GetMarkerRadius (const G4VMarker &, MarkerSizeType &)
 
G4ModelingParametersCreateModelingParameters ()
 
void DrawEvent (const G4Event *)
 
void DrawEndOfRunModels ()
 
template<class T >
void AddSolidT (const T &solid)
 
template<class T >
void AddSolidWithAuxiliaryEdges (const T &solid)
 
G4int IncrementViewCount ()
 
virtual void ClearStore ()
 
virtual void ClearTransientStore ()
 
void AddViewerToList (G4VViewer *pView)
 
void RemoveViewerFromList (G4VViewer *pView)
 
- Public Member Functions inherited from G4VGraphicsScene
 G4VGraphicsScene ()
 
virtual ~G4VGraphicsScene ()
 

Static Public Member Functions

static G4int GetEntitiesFlushInterval ()
 
static FlushAction GetFlushAction ()
 
static void SetEntitiesFlushInterval (G4int interval)
 
static void SetFlushAction (FlushAction action)
 

Protected Member Functions

 G4OpenGLSceneHandler (G4VGraphicsSystem &system, G4int id, const G4String &name="")
 
virtual ~G4OpenGLSceneHandler ()
 
void ProcessScene ()
 
G4DisplacedSolidCreateSectionSolid ()
 
G4DisplacedSolidCreateCutawaySolid ()
 
void ClearAndDestroyAtts ()
 
void ScaledFlush ()
 
- Protected Member Functions inherited from G4VSceneHandler
virtual void RequestPrimitives (const G4VSolid &solid)
 
void LoadAtts (const G4Visible &, G4AttHolder *)
 
void StandardSpecialMeshRendering (const G4Mesh &)
 
void Draw3DRectMeshAsDots (const G4Mesh &)
 
void Draw3DRectMeshAsSurfaces (const G4Mesh &)
 
void DrawTetMeshAsDots (const G4Mesh &)
 
void DrawTetMeshAsSurfaces (const G4Mesh &)
 
G4ThreeVector GetPointInBox (const G4ThreeVector &pos, G4double halfX, G4double halfY, G4double halfZ) const
 
G4ThreeVector GetPointInTet (const std::vector< G4ThreeVector > &vertices) const
 

Protected Attributes

GLuint fPickName
 
std::map< GLuint, G4AttHolder * > fPickMap
 
G4bool fThreePassCapable
 
G4bool fSecondPassForTransparencyRequested
 
G4bool fSecondPassForTransparency
 
G4bool fThirdPassForNonHiddenMarkersRequested
 
G4bool fThirdPassForNonHiddenMarkers
 
bool fEdgeFlag
 
- Protected Attributes inherited from G4VSceneHandler
G4VGraphicsSystemfSystem
 
const G4int fSceneHandlerId
 
G4String fName
 
G4int fViewCount
 
G4ViewerList fViewerList
 
G4VViewerfpViewer
 
G4ScenefpScene
 
G4bool fMarkForClearingTransientStore
 
G4bool fReadyForTransients
 
G4bool fTransientsDrawnThisEvent
 
G4bool fTransientsDrawnThisRun
 
G4bool fProcessingSolid
 
G4bool fProcessing2D
 
G4VModelfpModel
 
G4Transform3D fObjectTransformation
 
G4int fNestingDepth
 
const G4VisAttributesfpVisAttribs
 
const G4Transform3D fIdentityTransformation
 

Static Protected Attributes

static FlushAction fFlushAction = G4OpenGLSceneHandler::NthEvent
 
static G4int fEntitiesFlushInterval = 100
 
static const GLubyte fStippleMaskHashed [128]
 

Friends

class G4OpenGLViewer
 

Detailed Description

Definition at line 46 of file G4OpenGLSceneHandler.hh.

Member Enumeration Documentation

◆ FlushAction

Constructor & Destructor Documentation

◆ G4OpenGLSceneHandler()

G4OpenGLSceneHandler::G4OpenGLSceneHandler ( G4VGraphicsSystem & system,
G4int id,
const G4String & name = "" )
protected

Definition at line 83 of file G4OpenGLSceneHandler.cc.

◆ ~G4OpenGLSceneHandler()

G4OpenGLSceneHandler::~G4OpenGLSceneHandler ( )
protectedvirtual

Definition at line 97 of file G4OpenGLSceneHandler.cc.

98{
99 ClearStore ();
100}
virtual void ClearStore()

Member Function Documentation

◆ AddCompound() [1/6]

void G4OpenGLSceneHandler::AddCompound ( const G4Mesh & mesh)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 857 of file G4OpenGLSceneHandler.cc.

857 {
859}
void StandardSpecialMeshRendering(const G4Mesh &)

◆ AddCompound() [2/6]

void G4OpenGLSceneHandler::AddCompound ( const G4THitsMap< G4double > & hits)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 849 of file G4OpenGLSceneHandler.cc.

849 {
850 G4VSceneHandler::AddCompound(hits); // For now.
851}
virtual void AddCompound(const G4VTrajectory &)

◆ AddCompound() [3/6]

void G4OpenGLSceneHandler::AddCompound ( const G4THitsMap< G4StatDouble > & hits)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 853 of file G4OpenGLSceneHandler.cc.

853 {
854 G4VSceneHandler::AddCompound(hits); // For now.
855}

◆ AddCompound() [4/6]

void G4OpenGLSceneHandler::AddCompound ( const G4VDigi & digi)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 845 of file G4OpenGLSceneHandler.cc.

845 {
846 G4VSceneHandler::AddCompound(digi); // For now.
847}

◆ AddCompound() [5/6]

void G4OpenGLSceneHandler::AddCompound ( const G4VHit & hit)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 841 of file G4OpenGLSceneHandler.cc.

841 {
842 G4VSceneHandler::AddCompound(hit); // For now.
843}

◆ AddCompound() [6/6]

void G4OpenGLSceneHandler::AddCompound ( const G4VTrajectory & traj)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 837 of file G4OpenGLSceneHandler.cc.

837 {
838 G4VSceneHandler::AddCompound(traj); // For now.
839}

◆ AddPrimitive() [1/7]

void G4OpenGLSceneHandler::AddPrimitive ( const G4Circle & circle)
virtual

Implements G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 494 of file G4OpenGLSceneHandler.cc.

494 {
495 G4Polymarker oneCircle(circle);
496 oneCircle.push_back(circle.GetPosition());
497 oneCircle.SetMarkerType(G4Polymarker::circles);
498 // Call this AddPrimitive to avoid re-doing sub-class code.
500}
void AddPrimitive(const G4Polyline &)
G4Point3D GetPosition() const

◆ AddPrimitive() [2/7]

void G4VSceneHandler::AddPrimitive ( const G4Plotter & )
virtual

Reimplemented from G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 193 of file G4VSceneHandler.cc.

512 {
513 G4warn << "WARNING: Plotter not implemented for " << fSystem.GetName() << G4endl;
514 G4warn << " Open a plotter-aware graphics system or remove plotter with" << G4endl;
515 G4warn << " /vis/scene/removeModel Plotter" << G4endl;
516}
#define G4warn
Definition G4Scene.cc:41
#define G4endl
Definition G4ios.hh:67
const G4String & GetName() const
G4VGraphicsSystem & fSystem

◆ AddPrimitive() [3/7]

void G4OpenGLSceneHandler::AddPrimitive ( const G4Polyhedron & polyhedron)
virtual

Implements G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 511 of file G4OpenGLSceneHandler.cc.

511 {
512
513 // Assume all facets are planar convex quadrilaterals.
514 // Draw each facet individually
515
516 if (polyhedron.GetNoFacets() == 0) return;
517
518 // Need access to data in G4OpenGLViewer. static_cast doesn't work
519 // with a virtual base class, so use dynamic_cast.
520 G4OpenGLViewer* pGLViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
521 if (!pGLViewer) return;
522
523 // Get view parameters that the user can force through the vis
524 // attributes, thereby over-riding the current view parameter.
526
527 // Note that in stored mode, because this call gets embedded in a display
528 // list, it is the colour _at the time of_ creation of the display list, so
529 // even if the colour is changed, for example, by interaction with a Qt
530 // window, current_colour does not change.
531 GLfloat* painting_colour;
532 GLfloat clear_colour[4];
533 GLfloat current_colour[4];
534 glGetFloatv (GL_CURRENT_COLOR, current_colour);
535
536 G4bool isTransparent = false;
537 if (current_colour[3] < 1.) { // This object is transparent
538 isTransparent = true;
539 }
540
541 if (drawing_style == G4ViewParameters::hlr) {
542 // This is the colour used to paint surfaces in hlr mode.
543 glGetFloatv (GL_COLOR_CLEAR_VALUE, clear_colour);
544 painting_colour = clear_colour;
545 } else { // drawing_style == G4ViewParameters::hlhsr
546 painting_colour = current_colour;
547 }
548
550 pGLViewer->ChangeLineWidth(lineWidth);
551
552 G4bool isAuxEdgeVisible = GetAuxEdgeVisible (fpVisAttribs);
553
554 G4bool clipping = pGLViewer->fVP.IsSection() || pGLViewer->fVP.IsCutaway();
555
556 // Lighting disabled unless otherwise requested
557 glDisable (GL_LIGHTING);
558
559 switch (drawing_style) {
561 // Set up as for hidden line removal but paint polygon faces later...
563 glEnable (GL_STENCIL_TEST);
564 // The stencil buffer is cleared in G4OpenGLViewer::ClearView.
565 // The procedure below leaves it clear.
566 glStencilFunc (GL_ALWAYS, 0, 1);
567 glStencilOp (GL_INVERT, GL_INVERT, GL_INVERT);
568 glEnable (GL_DEPTH_TEST);
569 glDepthFunc (GL_LEQUAL);
570 if (isTransparent) {
571 // Transparent...
572 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
573 glEnable(GL_COLOR_MATERIAL);
574 //glDisable (GL_CULL_FACE);
575 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
576 } else {
577 // Opaque...
578 if (clipping) {
579 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
580 glEnable(GL_COLOR_MATERIAL);
581 //glDisable (GL_CULL_FACE);
582 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
583 } else {
584 glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
585 glEnable(GL_COLOR_MATERIAL);
586 //glEnable (GL_CULL_FACE);
587 //glCullFace (GL_BACK);
588 glPolygonMode (GL_FRONT, GL_LINE);
589 }
590 }
591 break;
593 glEnable (GL_DEPTH_TEST);
594 glDepthFunc (GL_LEQUAL);
595 if (isTransparent) {
596 // Transparent...
597 glDepthMask (GL_FALSE); // Make depth buffer read-only.
598 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
599 glEnable(GL_COLOR_MATERIAL);
600 //glDisable (GL_CULL_FACE);
601 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
602 } else {
603 // Opaque...
604 glDepthMask (GL_TRUE); // Make depth buffer writable (default).
605 if (clipping) {
606 glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
607 glEnable(GL_COLOR_MATERIAL);
608 //glDisable (GL_CULL_FACE);
609 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
610 } else {
611 glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
612 glEnable(GL_COLOR_MATERIAL);
613 //glEnable (GL_CULL_FACE);
614 //glCullFace (GL_BACK);
615 glPolygonMode (GL_FRONT, GL_FILL);
616 }
617 }
618 if (!fProcessing2D) glEnable (GL_LIGHTING);
619 break;
621 default:
622 glEnable (GL_DEPTH_TEST);
623 glDepthFunc (GL_LEQUAL); //??? was GL_ALWAYS
624 //glDisable (GL_CULL_FACE);
625 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
626 break;
627 }
628
629 //Loop through all the facets...
630 fEdgeFlag = true;
631 glBegin (GL_QUADS);
632 glEdgeFlag (GL_TRUE);
633 G4bool notLastFace;
634 do {
635
636 //First, find vertices, edgeflags and normals and note "not last facet"...
637 G4Point3D vertex[4];
638 G4int edgeFlag[4];
639 G4Normal3D normals[4];
640 G4int nEdges;
641 notLastFace = polyhedron.GetNextFacet(nEdges, vertex, edgeFlag, normals);
642
643 //Loop through the four edges of each G4Facet...
644 for(G4int edgeCount = 0; edgeCount < nEdges; ++edgeCount) {
645 // Check to see if edge is visible or not...
646 if (isAuxEdgeVisible) {
647 edgeFlag[edgeCount] = 1;
648 }
649 if (edgeFlag[edgeCount] > 0) {
650 if (fEdgeFlag != true) {
651 glEdgeFlag (GL_TRUE);
652 fEdgeFlag = true;
653 }
654 } else {
655 if (fEdgeFlag != false) {
656 glEdgeFlag (GL_FALSE);
657 fEdgeFlag = false;
658 }
659 }
660 glNormal3d (normals[edgeCount].x(),
661 normals[edgeCount].y(),
662 normals[edgeCount].z());
663 glVertex3d (vertex[edgeCount].x(),
664 vertex[edgeCount].y(),
665 vertex[edgeCount].z());
666 }
667
668 // HepPolyhedron produces triangles too; in that case add an extra
669 // vertex identical to first...
670 if (nEdges == 3) {
671 G4int edgeCount = 3;
672 normals[edgeCount] = normals[0];
673 vertex[edgeCount] = vertex[0];
674 edgeFlag[edgeCount] = -1;
675 if (fEdgeFlag != false) {
676 glEdgeFlag (GL_FALSE);
677 fEdgeFlag = false;
678 }
679
680 glNormal3d (normals[edgeCount].x(),
681 normals[edgeCount].y(),
682 normals[edgeCount].z());
683 glVertex3d (vertex[edgeCount].x(),
684 vertex[edgeCount].y(),
685 vertex[edgeCount].z());
686 }
687 // Trap situation where number of edges is > 4...
688 if (nEdges > 4) {
689 G4cerr <<
690 "G4OpenGLSceneHandler::AddPrimitive(G4Polyhedron): WARNING"
691 "\n G4Polyhedron facet with " << nEdges << " edges" << G4endl;
692 }
693
694
695 // Do it all over again (twice) for hlr...
696 if (drawing_style == G4ViewParameters::hlr ||
697 drawing_style == G4ViewParameters::hlhsr) {
698
699 glDisable(GL_COLOR_MATERIAL); // Revert to glMaterial for hlr/sr.
700 glEnd (); // Placed here to balance glBegin above, allowing GL
701
702 // state changes below, then glBegin again. Avoids
703 // having glBegin/End pairs *inside* loop in the more
704 // usual case of no hidden line removal.
705
706 // Lighting disabled unless otherwise requested
707 glDisable (GL_LIGHTING);
708
709 // Draw through stencil...
710 glStencilFunc (GL_EQUAL, 0, 1);
711 glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
712 if (drawing_style == G4ViewParameters::hlhsr) {
713 if (!fProcessing2D) glEnable (GL_LIGHTING);
714 }
715 glEnable (GL_DEPTH_TEST);
716 glDepthFunc (GL_LEQUAL);
717 if (isTransparent) {
718 // Transparent...
719 glDepthMask (GL_FALSE); // Make depth buffer read-only.
720 //glDisable (GL_CULL_FACE);
721 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
722 } else {
723 // Opaque...
724 glDepthMask (GL_TRUE); // Make depth buffer writable (default).
725 if (clipping) {
726 //glDisable (GL_CULL_FACE);
727 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
728 } else {
729 //glEnable (GL_CULL_FACE);
730 //glCullFace (GL_BACK);
731 glPolygonMode (GL_FRONT, GL_FILL);
732 }
733 }
734 if (drawing_style == G4ViewParameters::hlr) {
735 if (isTransparent) {
736 // Transparent - don't paint...
737 goto end_of_drawing_through_stencil;
738 }
739 }
740 if (isTransparent) {
741 // Transparent...
742 glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, painting_colour);
743 } else {
744 // Opaque...
745 glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, painting_colour);
746 }
747 glColor4fv (painting_colour);
748 glBegin (GL_QUADS);
749 glEdgeFlag (GL_TRUE);
750 fEdgeFlag = true;
751
752 for (int edgeCount = 0; edgeCount < 4; ++edgeCount) {
753 if (edgeFlag[edgeCount] > 0) {
754 if (fEdgeFlag != true) {
755 glEdgeFlag (GL_TRUE);
756 fEdgeFlag = true;
757 }
758 } else {
759 if (fEdgeFlag != false) {
760 glEdgeFlag (GL_FALSE);
761 fEdgeFlag = false;
762 }
763 }
764 glNormal3d (normals[edgeCount].x(),
765 normals[edgeCount].y(),
766 normals[edgeCount].z());
767 glVertex3d (vertex[edgeCount].x(),
768 vertex[edgeCount].y(),
769 vertex[edgeCount].z());
770 }
771 glEnd ();
772 end_of_drawing_through_stencil:
773
774 // and once more to reset the stencil bits...
775 glStencilFunc (GL_ALWAYS, 0, 1);
776 glStencilOp (GL_INVERT, GL_INVERT, GL_INVERT);
777 glDepthFunc (GL_LEQUAL); // to make sure line gets drawn.
778 if (isTransparent) {
779 // Transparent...
780 //glDisable (GL_CULL_FACE);
781 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
782 } else {
783 // Opaque...
784 if (clipping) {
785 //glDisable (GL_CULL_FACE);
786 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
787 } else {
788 //glEnable (GL_CULL_FACE);
789 //glCullFace (GL_BACK);
790 glPolygonMode (GL_FRONT, GL_LINE);
791 }
792 }
793 glDisable (GL_LIGHTING);
794 glColor4fv (current_colour);
795 fEdgeFlag = true;
796 glBegin (GL_QUADS);
797 glEdgeFlag (GL_TRUE);
798 fEdgeFlag = true;
799 for (int edgeCount = 0; edgeCount < 4; ++edgeCount) {
800 if (edgeFlag[edgeCount] > 0) {
801 if (fEdgeFlag != true) {
802 glEdgeFlag (GL_TRUE);
803 fEdgeFlag = true;
804 }
805 } else {
806 if (fEdgeFlag != false) {
807 glEdgeFlag (GL_FALSE);
808 fEdgeFlag = false;
809 }
810 }
811 glNormal3d (normals[edgeCount].x(),
812 normals[edgeCount].y(),
813 normals[edgeCount].z());
814 glVertex3d (vertex[edgeCount].x(),
815 vertex[edgeCount].y(),
816 vertex[edgeCount].z());
817 }
818 glEnd ();
819
820 glDepthFunc (GL_LEQUAL); // Revert for next facet.
821 fEdgeFlag = true;
822 glBegin (GL_QUADS); // Ready for next facet. GL
823 glEdgeFlag (GL_TRUE);
824 fEdgeFlag = true;
825 // says it ignores incomplete
826 // quadrilaterals, so final empty
827 // glBegin/End sequence should be OK.
828 }
829 } while (notLastFace);
830
831 glEnd ();
832 glDisable (GL_STENCIL_TEST); // Revert to default for next primitive.
833 glDepthMask (GL_TRUE); // Revert to default for next primitive.
834 glDisable (GL_LIGHTING); // Revert to default for next primitive.
835}
double G4double
Definition G4Types.hh:83
bool G4bool
Definition G4Types.hh:86
int G4int
Definition G4Types.hh:85
G4GLOB_DLL std::ostream G4cerr
void ChangeLineWidth(G4double width)
const G4VisAttributes * fpVisAttribs
G4ViewParameters::DrawingStyle GetDrawingStyle(const G4VisAttributes *)
G4double GetLineWidth(const G4VisAttributes *)
G4bool GetAuxEdgeVisible(const G4VisAttributes *)
G4ViewParameters fVP
Definition G4VViewer.hh:257
G4bool IsCutaway() const
G4bool IsSection() const
G4int GetNoFacets() const
G4bool GetNextFacet(G4int &n, G4Point3D *nodes, G4int *edgeFlags=nullptr, G4Normal3D *normals=nullptr) const

◆ AddPrimitive() [4/7]

void G4OpenGLSceneHandler::AddPrimitive ( const G4Polyline & line)
virtual

Implements G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 342 of file G4OpenGLSceneHandler.cc.

343{
344 std::size_t nPoints = line.size ();
345 if (nPoints <= 0) return;
346
347 // Note: colour and depth test treated in sub-class.
348
349 glDisable (GL_LIGHTING);
350
352 // Need access to method in G4OpenGLViewer. static_cast doesn't
353 // work with a virtual base class, so use dynamic_cast. No need to
354 // test the outcome since viewer is guaranteed to be a
355 // G4OpenGLViewer, but test it anyway to keep Coverity happy.
356 G4OpenGLViewer* pGLViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
357 if (pGLViewer) pGLViewer->ChangeLineWidth(lineWidth);
358
359 fEdgeFlag = true;
360 glBegin (GL_LINE_STRIP);
361 // No ned glEdgeFlag for lines :
362 // Boundary and nonboundary edge flags on vertices are significant only if GL_POLYGON_MODE is set to GL_POINT or GL_LINE. See glPolygonMode.
363
364 // glEdgeFlag (GL_TRUE);
365 for (std::size_t iPoint = 0; iPoint < nPoints; ++iPoint) {
366 G4double x, y, z;
367 x = line[iPoint].x();
368 y = line[iPoint].y();
369 z = line[iPoint].z();
370 glVertex3d (x, y, z);
371 }
372 glEnd ();
373}

Referenced by G4OpenGLImmediateSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitive(), AddPrimitive(), AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitive(), and G4OpenGLStoredSceneHandler::AddPrimitive().

◆ AddPrimitive() [5/7]

void G4OpenGLSceneHandler::AddPrimitive ( const G4Polymarker & polymarker)
virtual

Reimplemented from G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 375 of file G4OpenGLSceneHandler.cc.

376{
377 if (polymarker.size() == 0) {
378 return;
379 }
380
381 // Note: colour and depth test treated in sub-class.
382
383 glDisable (GL_LIGHTING);
384
385 MarkerSizeType sizeType;
386 G4double size = GetMarkerSize(polymarker, sizeType);
387
388 // Need access to method in G4OpenGLViewer. static_cast doesn't
389 // work with a virtual base class, so use dynamic_cast. No need to
390 // test the outcome since viewer is guaranteed to be a
391 // G4OpenGLViewer, but test it anyway to keep Coverity happy.
392 G4OpenGLViewer* pGLViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
393 if (!pGLViewer) return;
394
395 if (sizeType == world) { // Size specified in world coordinates.
397 pGLViewer->ChangeLineWidth(lineWidth);
398
399 G4VMarker::FillStyle style = polymarker.GetFillStyle();
400
401 // G4bool filled = false; Not actually used - comment out to prevent compiler warnings (JA).
402 static G4bool hashedWarned = false;
403
404 switch (style) {
406 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
407 glEdgeFlag (GL_TRUE);
408 //filled = false;
409 break;
411 if (!hashedWarned) {
412 G4cout << "Hashed fill style in G4OpenGLSceneHandler."
413 << "\n Not implemented. Using G4VMarker::filled."
414 << G4endl;
415 hashedWarned = true;
416 }
417 // Maybe use
418 //glPolygonStipple (fStippleMaskHashed);
419 [[fallthrough]]; // Drop through to filled...
421 glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
422 //filled = true;
423 break;
424 }
425 }
426
427 // Draw...
428 if (sizeType == world) { // Size specified in world coordinates.
429
430 G4int nSides;
431 G4double startPhi;
432 switch (polymarker.GetMarkerType()) {
433 default:
435 size = 1.;
436 [[fallthrough]]; // Fall through to circles
438 nSides = GetNoOfSides(fpVisAttribs);
439 startPhi = 0.;
440 break;
442 nSides = 4;
443 startPhi = -pi / 4.;
444 break;
445 }
446
447 const G4Vector3D& viewpointDirection =
448 fpViewer -> GetViewParameters().GetViewpointDirection();
450 const G4double dPhi = twopi / nSides;
451 const G4double radius = size / 2.;
452 G4Vector3D start = radius * (up.cross(viewpointDirection)).unit();
453 G4double phi;
454 G4int i;
455 for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
456 fEdgeFlag = true;
457 glBegin (GL_POLYGON);
458 for (i = 0, phi = startPhi; i < nSides; i++, phi += dPhi) {
459 G4Vector3D r = start; r.rotate(phi, viewpointDirection);
460 G4Vector3D p = polymarker[iPoint] + r;
461 glVertex3d (p.x(), p.y(), p.z());
462 }
463 glEnd ();
464 }
465
466 } else { // Size specified in screen (window) coordinates.
467
468 pGLViewer->ChangePointSize(size);
469
470 //Antialiasing only for circles
471 switch (polymarker.GetMarkerType()) {
472 default:
475 glEnable (GL_POINT_SMOOTH); break;
477 glDisable (GL_POINT_SMOOTH); break;
478 }
479 glBegin (GL_POINTS);
480 for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
481 G4Point3D centre = polymarker[iPoint];
482 glVertex3d(centre.x(),centre.y(),centre.z());
483 }
484 glEnd();
485 }
486}
G4GLOB_DLL std::ostream G4cout
void ChangePointSize(G4double size)
MarkerType GetMarkerType() const
FillStyle GetFillStyle() const
G4int GetNoOfSides(const G4VisAttributes *)
G4double GetMarkerSize(const G4VMarker &, MarkerSizeType &)
const G4ViewParameters & GetViewParameters() const
const G4Vector3D & GetUpVector() const
BasicVector3D< T > cross(const BasicVector3D< T > &v) const
BasicVector3D< T > & rotate(T a, const BasicVector3D< T > &v)
BasicVector3D< T > unit() const

◆ AddPrimitive() [6/7]

void G4OpenGLSceneHandler::AddPrimitive ( const G4Square & square)
virtual

Implements G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 502 of file G4OpenGLSceneHandler.cc.

502 {
503 G4Polymarker oneSquare(square);
504 oneSquare.push_back(square.GetPosition());
505 oneSquare.SetMarkerType(G4Polymarker::squares);
506 // Call this AddPrimitive to avoid re-doing sub-class code.
508}

◆ AddPrimitive() [7/7]

void G4OpenGLSceneHandler::AddPrimitive ( const G4Text & text)
virtual

Implements G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 488 of file G4OpenGLSceneHandler.cc.

488 {
489 // Pass to specific viewer via virtual function DrawText.
490 G4OpenGLViewer* pGLViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
491 if (pGLViewer) pGLViewer->DrawText(text);
492}
virtual void DrawText(const G4Text &)

◆ AddPrimitivesCircle()

void G4OpenGLSceneHandler::AddPrimitivesCircle ( const std::vector< G4VMarker > & )

◆ AddPrimitivesSquare()

void G4OpenGLSceneHandler::AddPrimitivesSquare ( const std::vector< G4VMarker > & )

◆ AddSolid() [1/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Box & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [2/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Cons & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [3/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Ellipsoid & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [4/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Orb & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [5/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Para & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [6/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Polycone & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [7/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Polyhedra & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [8/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Sphere & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [9/14]

void G4OpenGLSceneHandler::AddSolid ( const G4TessellatedSolid & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [10/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Torus & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [11/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Trap & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [12/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Trd & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [13/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Tubs & )
virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [14/14]

void G4OpenGLSceneHandler::AddSolid ( const G4VSolid & )
virtual

Reimplemented from G4VSceneHandler.

◆ BeginPrimitives()

void G4OpenGLSceneHandler::BeginPrimitives ( const G4Transform3D & objectTransformation)
virtual

Reimplemented from G4VSceneHandler.

Reimplemented in G4OpenGLImmediateSceneHandler, and G4OpenGLStoredSceneHandler.

Definition at line 302 of file G4OpenGLSceneHandler.cc.

304{
305 G4VSceneHandler::BeginPrimitives (objectTransformation);
306}
virtual void BeginPrimitives(const G4Transform3D &objectTransformation=G4Transform3D())

Referenced by G4OpenGLImmediateSceneHandler::BeginPrimitives(), and G4OpenGLStoredSceneHandler::BeginPrimitives().

◆ BeginPrimitives2D()

void G4OpenGLSceneHandler::BeginPrimitives2D ( const G4Transform3D & objectTransformation)
virtual

Reimplemented from G4VSceneHandler.

Reimplemented in G4OpenGLImmediateSceneHandler, and G4OpenGLStoredSceneHandler.

Definition at line 313 of file G4OpenGLSceneHandler.cc.

315{
316 G4VSceneHandler::BeginPrimitives2D (objectTransformation);
317}
virtual void BeginPrimitives2D(const G4Transform3D &objectTransformation=G4Transform3D())

Referenced by G4OpenGLImmediateSceneHandler::BeginPrimitives2D(), and G4OpenGLStoredSceneHandler::BeginPrimitives2D().

◆ ClearAndDestroyAtts()

void G4OpenGLSceneHandler::ClearAndDestroyAtts ( )
protected

Definition at line 102 of file G4OpenGLSceneHandler.cc.

103{
104 std::map<GLuint, G4AttHolder*>::iterator i;
105 for (i = fPickMap.begin(); i != fPickMap.end(); ++i) delete i->second;
106 fPickMap.clear();
107}
std::map< GLuint, G4AttHolder * > fPickMap

Referenced by G4OpenGLStoredSceneHandler::ClearStore().

◆ CreateCutawaySolid()

G4DisplacedSolid * G4OpenGLSceneHandler::CreateCutawaySolid ( )
protectedvirtual

Reimplemented from G4VSceneHandler.

Definition at line 333 of file G4OpenGLSceneHandler.cc.

334{
335 // return G4VSceneHandler::CreateCutawaySolid();
336 // If cutaway done in G4OpenGLViewer::SetView.
337 return 0;
338 // Note: if you change this, you must also change
339 // G4OpenGLStoredViewer::CompareForKernelVisit
340}

◆ CreateSectionSolid()

G4DisplacedSolid * G4OpenGLSceneHandler::CreateSectionSolid ( )
protectedvirtual

Reimplemented from G4VSceneHandler.

Definition at line 324 of file G4OpenGLSceneHandler.cc.

325{
327 // If clipping done in G4OpenGLViewer::SetView
328 // return 0;
329 // Note: if you change this, you must also change
330 // G4OpenGLStoredViewer::CompareForKernelVisit
331}
virtual G4DisplacedSolid * CreateSectionSolid()

◆ EndPrimitives()

void G4OpenGLSceneHandler::EndPrimitives ( )
virtual

◆ EndPrimitives2D()

void G4OpenGLSceneHandler::EndPrimitives2D ( )
virtual

◆ GetEntitiesFlushInterval()

static G4int G4OpenGLSceneHandler::GetEntitiesFlushInterval ( )
inlinestatic

Definition at line 97 of file G4OpenGLSceneHandler.hh.

◆ GetFlushAction()

static FlushAction G4OpenGLSceneHandler::GetFlushAction ( )
inlinestatic

Definition at line 99 of file G4OpenGLSceneHandler.hh.

100 {return fFlushAction;}
static FlushAction fFlushAction

◆ PreAddSolid()

void G4OpenGLSceneHandler::PreAddSolid ( const G4Transform3D & objectTransformation,
const G4VisAttributes & visAttribs )
virtual

Reimplemented from G4VSceneHandler.

Definition at line 295 of file G4OpenGLSceneHandler.cc.

298{
299 G4VSceneHandler::PreAddSolid (objectTransformation, visAttribs);
300}
virtual void PreAddSolid(const G4Transform3D &objectTransformation, const G4VisAttributes &)

◆ ProcessScene()

void G4OpenGLSceneHandler::ProcessScene ( )
protectedvirtual

Reimplemented from G4VSceneHandler.

Definition at line 270 of file G4OpenGLSceneHandler.cc.

271{
272 fThreePassCapable = true;
273
275
276 // Repeat if required...
282 }
283
284 // And again if required...
290 }
291
292 fThreePassCapable = false;
293}
virtual void ProcessScene()

◆ ScaledFlush()

void G4OpenGLSceneHandler::ScaledFlush ( )
protected

Definition at line 113 of file G4OpenGLSceneHandler.cc.

114{
116
117 // Drawing transients, e.g., trajectories.
118
119 if (!fpScene) {
120 // No scene - shouldn't happen
121 glFlush();
122 return;
123 }
124 // Get event from modeling parameters
125 if (!fpModel) {
126 // No model - shouldn't happen
127 glFlush();
128 return;
129 }
130 const G4ModelingParameters* modelingParameters =
132 if (!modelingParameters) {
133 // No modeling parameters - shouldn't happen
134 glFlush();
135 return;
136 }
137 const G4Event* thisEvent = modelingParameters->GetEvent();
138 if (!thisEvent) {
139 // No event, so not in event loop.
140 if (fFlushAction == endOfEvent) {
142 } else if (fFlushAction == NthEvent) {
144 }
145 }
147 if (!runMan) {
148 // No run manager - shouldn't happen
149 glFlush();
150 return;
151 }
152 const G4Run* thisRun = runMan->GetCurrentRun();
153 if (!thisRun) {
154 // No run, so not in event loop.
155 if (fFlushAction == endOfRun) {
157 } else if (fFlushAction == NthEvent) {
159 }
160 }
161
162 switch (fFlushAction) {
163 case endOfEvent:
164 // If "/vis/scene/endOfEventAction refresh", primitives are flushed at
165 // end of run anyway, so only scale if false.
167 // But if "/vis/scene/endOfEventAction accumulate", ShowView is not
168 // called until end of run, so we have to watch for a new event.
169 // Get event from modeling parameters
170 G4int thisEventID = thisEvent->GetEventID();
171 static G4int lastEventID = 0;
172 if (thisEventID != lastEventID) {
173 glFlush();
174 lastEventID = thisEventID;
175 }
176 }
177 break;
178 case endOfRun:
179 // If "/vis/scene/endOfRunAction refresh", primitives are flushed at
180 // end of run anyway, so only scale if false.
182 // If "/vis/scene/endOfRunAction accumulate", ShowView is never called
183 // so we have to watch for a new run.
184 G4int thisRunID = thisRun->GetRunID();
185 static G4int lastRunID = 0;
186 if (thisRunID != lastRunID) {
187 glFlush();
188 lastRunID = thisRunID;
189 }
190 }
191 break;
192 case eachPrimitive:
193 // This is equivalent to numeric with fEntitiesFlushInterval == 1.
195 [[fallthrough]]; // Fall through to NthPrimitive.
196 case NthPrimitive:
197 { // Encapsulate in scope {} brackets to satisfy Windows.
198 static G4int primitivesWaitingToBeFlushed = 0;
199 primitivesWaitingToBeFlushed++;
200 if (primitivesWaitingToBeFlushed < fEntitiesFlushInterval) return;
201 glFlush();
202 primitivesWaitingToBeFlushed = 0;
203 break;
204 }
205 case NthEvent:
206 // If "/vis/scene/endOfEventAction refresh", primitives are flushed at
207 // end of event anyway, so only scale if false.
209 G4int thisEventID = thisEvent->GetEventID();
210 static G4int lastEventID = 0;
211 if (thisEventID != lastEventID) {
212 static G4int eventsWaitingToBeFlushed = 0;
213 eventsWaitingToBeFlushed++;
214 if (eventsWaitingToBeFlushed < fEntitiesFlushInterval) return;
215 glFlush();
216 eventsWaitingToBeFlushed = 0;
217 lastEventID = thisEventID;
218 }
219 }
220 break;
221 case never:
222 break;
223 default:
224 break;
225 }
226
227 }
228
229 else
230
231 {
232
233 // For run duration model drawing (detector drawing):
234 // Immediate mode: a huge speed up is obtained if flushes are scaled.
235 // Stored mode: no discernable difference since drawing is done to the
236 // back buffer and then swapped.
237 // So eachPrimitive and NthPrimitive make sense. But endOfEvent and
238 // endOfRun are treated as "no action", i.e., a flush will only be issued,
239 // as happens anyway, when drawing is complete.
240
241 switch (fFlushAction) {
242 case endOfEvent:
243 break;
244 case endOfRun:
245 break;
246 case eachPrimitive:
247 // This is equivalent to NthPrimitive with fEntitiesFlushInterval == 1.
249 [[fallthrough]]; // Fall through to NthPrimitive.
250 case NthPrimitive:
251 { // Encapsulate in scope {} brackets to satisfy Windows.
252 static G4int primitivesWaitingToBeFlushed = 0;
253 primitivesWaitingToBeFlushed++;
254 if (primitivesWaitingToBeFlushed < fEntitiesFlushInterval) return;
255 glFlush();
256 primitivesWaitingToBeFlushed = 0;
257 break;
258 }
259 case NthEvent:
260 break;
261 case never:
262 break;
263 default:
264 break;
265 }
266
267 }
268}
G4int GetEventID() const
Definition G4Event.hh:123
const G4Event * GetEvent() const
static G4RunManager * GetMasterRunManager()
const G4Run * GetCurrentRun() const
Definition G4Run.hh:49
G4int GetRunID() const
Definition G4Run.hh:86
G4bool GetRefreshAtEndOfEvent() const
G4bool GetRefreshAtEndOfRun() const
const G4ModelingParameters * GetModelingParameters() const

Referenced by G4OpenGLImmediateSceneHandler::EndPrimitives(), G4OpenGLStoredSceneHandler::EndPrimitives(), G4OpenGLImmediateSceneHandler::EndPrimitives2D(), and G4OpenGLStoredSceneHandler::EndPrimitives2D().

◆ SetEntitiesFlushInterval()

static void G4OpenGLSceneHandler::SetEntitiesFlushInterval ( G4int interval)
inlinestatic

Definition at line 101 of file G4OpenGLSceneHandler.hh.

102 {fEntitiesFlushInterval = interval;}

Referenced by G4OpenGLViewerMessenger::SetNewValue().

◆ SetFlushAction()

static void G4OpenGLSceneHandler::SetFlushAction ( FlushAction action)
inlinestatic

Definition at line 103 of file G4OpenGLSceneHandler.hh.

104 {fFlushAction = action;}

Referenced by G4OpenGLViewerMessenger::SetNewValue().

Friends And Related Symbol Documentation

◆ G4OpenGLViewer

friend class G4OpenGLViewer
friend

Definition at line 48 of file G4OpenGLSceneHandler.hh.

Member Data Documentation

◆ fEdgeFlag

bool G4OpenGLSceneHandler::fEdgeFlag
protected

Definition at line 139 of file G4OpenGLSceneHandler.hh.

Referenced by AddPrimitive(), AddPrimitive(), and AddPrimitive().

◆ fEntitiesFlushInterval

G4int G4OpenGLSceneHandler::fEntitiesFlushInterval = 100
staticprotected

◆ fFlushAction

G4OpenGLSceneHandler::FlushAction G4OpenGLSceneHandler::fFlushAction = G4OpenGLSceneHandler::NthEvent
staticprotected

Definition at line 125 of file G4OpenGLSceneHandler.hh.

Referenced by GetFlushAction(), ScaledFlush(), and SetFlushAction().

◆ fPickMap

std::map<GLuint, G4AttHolder*> G4OpenGLSceneHandler::fPickMap
protected

Definition at line 120 of file G4OpenGLSceneHandler.hh.

Referenced by ClearAndDestroyAtts(), and G4OpenGLViewer::GetPickDetails().

◆ fPickName

GLuint G4OpenGLSceneHandler::fPickName
protected

◆ fSecondPassForTransparency

G4bool G4OpenGLSceneHandler::fSecondPassForTransparency
protected

Definition at line 133 of file G4OpenGLSceneHandler.hh.

Referenced by ProcessScene().

◆ fSecondPassForTransparencyRequested

G4bool G4OpenGLSceneHandler::fSecondPassForTransparencyRequested
protected

Definition at line 132 of file G4OpenGLSceneHandler.hh.

Referenced by ProcessScene().

◆ fStippleMaskHashed

const GLubyte G4OpenGLSceneHandler::fStippleMaskHashed
staticprotected
Initial value:
= {
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
}

Definition at line 64 of file G4OpenGLSceneHandler.hh.

◆ fThirdPassForNonHiddenMarkers

G4bool G4OpenGLSceneHandler::fThirdPassForNonHiddenMarkers
protected

Definition at line 136 of file G4OpenGLSceneHandler.hh.

Referenced by ProcessScene().

◆ fThirdPassForNonHiddenMarkersRequested

G4bool G4OpenGLSceneHandler::fThirdPassForNonHiddenMarkersRequested
protected

Definition at line 135 of file G4OpenGLSceneHandler.hh.

Referenced by ProcessScene().

◆ fThreePassCapable

G4bool G4OpenGLSceneHandler::fThreePassCapable
protected

Definition at line 130 of file G4OpenGLSceneHandler.hh.

Referenced by ProcessScene().


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