Geant4 11.4.0
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 G4VisExtent & GetExtent () const
const G4String & GetName () const
G4int GetSceneHandlerId () const
G4int GetViewCount () const
G4VGraphicsSystem * GetGraphicsSystem () const
G4Scene * GetScene () const
const G4ViewerList & GetViewerList () const
G4VModel * GetModel () const
G4VViewer * GetCurrentViewer () const
G4bool GetMarkForClearingTransientStore () const
G4bool IsReadyForTransients () const
G4bool GetTransientsDrawnThisEvent () const
G4bool GetTransientsDrawnThisRun () const
const G4Transform3D & GetObjectTransformation () const
void SetName (const G4String &)
void SetCurrentViewer (G4VViewer *)
virtual void SetScene (G4Scene *)
G4ViewerList & SetViewerList ()
void SetModel (G4VModel *)
void SetMarkForClearingTransientStore (G4bool)
void SetTransientsDrawnThisEvent (G4bool)
void SetTransientsDrawnThisRun (G4bool)
void SetObjectTransformation (const G4Transform3D &)
const G4Colour & GetColour ()
const G4Colour & GetColor ()
const G4Colour & GetColour (const G4Visible &)
const G4Colour & GetColor (const G4Visible &)
const G4Colour & GetTextColour (const G4Text &)
const G4Colour & GetTextColor (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 &)
G4ModelingParameters * CreateModelingParameters ()
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 ()
G4int GetMaxGeometryDepth () const
void SetMaxGeometryDepth (G4int maxDepth)

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 ()
G4DisplacedSolid * CreateSectionSolid ()
G4DisplacedSolid * CreateCutawaySolid ()
void ClearAndDestroyAtts ()
void ScaledFlush ()
Protected Member Functions inherited from G4VSceneHandler
virtual void ProcessTransients ()
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
G4VGraphicsSystem & fSystem
const G4int fSceneHandlerId
G4String fName
G4int fViewCount
G4ViewerList fViewerList
G4VViewer * fpViewer
G4Scene * fpScene
G4bool fMarkForClearingTransientStore
G4bool fReadyForTransients
G4bool fTransientsDrawnThisEvent
G4bool fTransientsDrawnThisRun
G4bool fProcessingSolid
G4bool fProcessing2D
G4VModel * fpModel
G4Transform3D fObjectTransformation
G4int fNestingDepth
const G4VisAttributes * fpVisAttribs
const G4Transform3D fIdentityTransformation
std::map< G4VPhysicalVolume *, G4String > fProblematicVolumes
Protected Attributes inherited from G4VGraphicsScene
G4int fMaxGeometryDepth = 0

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

enum G4OpenGLSceneHandler::FlushAction
Enumerator
endOfEvent 
endOfRun 
eachPrimitive 
NthPrimitive 
NthEvent 
never 

Definition at line 89 of file G4OpenGLSceneHandler.hh.

89 {
90 endOfEvent,
91 endOfRun,
92 eachPrimitive,
93 NthPrimitive,
94 NthEvent,
95 never
96 };

Constructor & Destructor Documentation

◆ G4OpenGLSceneHandler()

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

Definition at line 83 of file G4OpenGLSceneHandler.cc.

85 :
86G4VSceneHandler (system, id, name),
87fPickName(0),
88fThreePassCapable(false),
89fSecondPassForTransparencyRequested(false),
90fSecondPassForTransparency(false),
91fThirdPassForNonHiddenMarkersRequested(false),
92fThirdPassForNonHiddenMarkers(false),
93fEdgeFlag(true)
94{
95}
G4VSceneHandler::G4VSceneHandler
G4VSceneHandler(G4VGraphicsSystem &system, G4int id, const G4String &name="")
Definition G4VSceneHandler.cc:99

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

◆ ~G4OpenGLSceneHandler()

G4OpenGLSceneHandler::~G4OpenGLSceneHandler ( )
protectedvirtual

Definition at line 97 of file G4OpenGLSceneHandler.cc.

98{
99 ClearStore ();
100}
G4VSceneHandler::ClearStore
virtual void ClearStore()
Definition G4VSceneHandler.cc:221

Member Function Documentation

◆ AddCompound() [1/6]

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

Reimplemented from G4VSceneHandler.

Definition at line 871 of file G4OpenGLSceneHandler.cc.

871 {
872 StandardSpecialMeshRendering(mesh);
873}
G4VSceneHandler::StandardSpecialMeshRendering
void StandardSpecialMeshRendering(const G4Mesh &)
Definition G4VSceneHandler.cc:1409

◆ AddCompound() [2/6]

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

Reimplemented from G4VSceneHandler.

Definition at line 863 of file G4OpenGLSceneHandler.cc.

863 {
864 G4VSceneHandler::AddCompound(hits); // For now.
865}
G4VSceneHandler::AddCompound
virtual void AddCompound(const G4VTrajectory &)
Definition G4VSceneHandler.cc:323

◆ AddCompound() [3/6]

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

Reimplemented from G4VSceneHandler.

Definition at line 867 of file G4OpenGLSceneHandler.cc.

867 {
868 G4VSceneHandler::AddCompound(hits); // For now.
869}

◆ AddCompound() [4/6]

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

Reimplemented from G4VSceneHandler.

Definition at line 859 of file G4OpenGLSceneHandler.cc.

859 {
860 G4VSceneHandler::AddCompound(digi); // For now.
861}

◆ AddCompound() [5/6]

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

Reimplemented from G4VSceneHandler.

Definition at line 855 of file G4OpenGLSceneHandler.cc.

855 {
856 G4VSceneHandler::AddCompound(hit); // For now.
857}

◆ AddCompound() [6/6]

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

Reimplemented from G4VSceneHandler.

Definition at line 851 of file G4OpenGLSceneHandler.cc.

851 {
852 G4VSceneHandler::AddCompound(traj); // For now.
853}

◆ AddPrimitive() [1/7]

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

Implements G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 508 of file G4OpenGLSceneHandler.cc.

508 {
509 G4Polymarker oneCircle(circle);
510 oneCircle.push_back(circle.GetPosition());
511 oneCircle.SetMarkerType(G4Polymarker::circles);
512 // Call this AddPrimitive to avoid re-doing sub-class code.
513 G4OpenGLSceneHandler::AddPrimitive(oneCircle);
514}
G4OpenGLSceneHandler::AddPrimitive
void AddPrimitive(const G4Polyline &)
Definition G4OpenGLSceneHandler.cc:354
G4VMarker::GetPosition
G4Point3D GetPosition() const

◆ AddPrimitive() [2/7]

void G4VSceneHandler::AddPrimitive ( const G4Plotter & )
virtual

Reimplemented from G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 195 of file G4VSceneHandler.cc.

508 {
509 G4warn << "WARNING: Plotter not implemented for " << fSystem.GetName() << G4endl;
510 G4warn << " Open a plotter-aware graphics system or remove plotter with" << G4endl;
511 G4warn << " /vis/scene/removeModel Plotter" << G4endl;
512}
G4warn
#define G4warn
Definition G4Scene.cc:41
G4endl
#define G4endl
Definition G4ios.hh:67
G4VSceneHandler::fSystem
G4VGraphicsSystem & fSystem
Definition G4VSceneHandler.hh:442

◆ AddPrimitive() [3/7]

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

Implements G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 525 of file G4OpenGLSceneHandler.cc.

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

◆ AddPrimitive() [4/7]

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

Implements G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 354 of file G4OpenGLSceneHandler.cc.

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

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 387 of file G4OpenGLSceneHandler.cc.

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

◆ AddPrimitive() [6/7]

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

Implements G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 516 of file G4OpenGLSceneHandler.cc.

516 {
517 G4Polymarker oneSquare(square);
518 oneSquare.push_back(square.GetPosition());
519 oneSquare.SetMarkerType(G4Polymarker::squares);
520 // Call this AddPrimitive to avoid re-doing sub-class code.
521 G4OpenGLSceneHandler::AddPrimitive(oneSquare);
522}

◆ AddPrimitive() [7/7]

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

Implements G4VSceneHandler.

Reimplemented in G4OpenGLStoredSceneHandler.

Definition at line 502 of file G4OpenGLSceneHandler.cc.

502 {
503 // Pass to specific viewer via virtual function DrawText.
504 G4OpenGLViewer* pGLViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
505 if (pGLViewer) pGLViewer->DrawText(text);
506}
G4OpenGLViewer::DrawText
virtual void DrawText(const G4Text &)
Definition G4OpenGLViewer.cc:705

◆ 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 glClearColor (0.0, 0.0, 0.0, 0.0);
306 glClearDepth (1.0);
307 glDisable (GL_LINE_SMOOTH);
308 glDisable (GL_POLYGON_SMOOTH);
309 glDisable (GL_POINT_SMOOTH);
310
311 G4VSceneHandler::BeginPrimitives (objectTransformation);
312}
G4VSceneHandler::BeginPrimitives
virtual void BeginPrimitives(const G4Transform3D &objectTransformation=G4Transform3D())
Definition G4VSceneHandler.cc:166

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 319 of file G4OpenGLSceneHandler.cc.

321{
322 glClearColor (0.0, 0.0, 0.0, 0.0);
323 glClearDepth (1.0);
324 glDisable (GL_LINE_SMOOTH);
325 glDisable (GL_POLYGON_SMOOTH);
326 glDisable (GL_POINT_SMOOTH);
327
328 G4VSceneHandler::BeginPrimitives2D (objectTransformation);
329}
G4VSceneHandler::BeginPrimitives2D
virtual void BeginPrimitives2D(const G4Transform3D &objectTransformation=G4Transform3D())
Definition G4VSceneHandler.cc:190

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}
G4OpenGLSceneHandler::fPickMap
std::map< GLuint, G4AttHolder * > fPickMap
Definition G4OpenGLSceneHandler.hh:120

Referenced by G4OpenGLStoredSceneHandler::ClearStore().

◆ CreateCutawaySolid()

G4DisplacedSolid * G4OpenGLSceneHandler::CreateCutawaySolid ( )
protectedvirtual

Reimplemented from G4VSceneHandler.

Definition at line 345 of file G4OpenGLSceneHandler.cc.

346{
347 // return G4VSceneHandler::CreateCutawaySolid();
348 // If cutaway done in G4OpenGLViewer::SetView.
349 return 0;
350 // Note: if you change this, you must also change
351 // G4OpenGLStoredViewer::CompareForKernelVisit
352}

◆ CreateSectionSolid()

G4DisplacedSolid * G4OpenGLSceneHandler::CreateSectionSolid ( )
protectedvirtual

Reimplemented from G4VSceneHandler.

Definition at line 336 of file G4OpenGLSceneHandler.cc.

337{
338 return G4VSceneHandler::CreateSectionSolid();
339 // If clipping done in G4OpenGLViewer::SetView
340 // return 0;
341 // Note: if you change this, you must also change
342 // G4OpenGLStoredViewer::CompareForKernelVisit
343}
G4VSceneHandler::CreateSectionSolid
virtual G4DisplacedSolid * CreateSectionSolid()
Definition G4VSceneHandler.cc:1028

◆ EndPrimitives()

void G4OpenGLSceneHandler::EndPrimitives ( )
virtual

Reimplemented from G4VSceneHandler.

Reimplemented in G4OpenGLImmediateSceneHandler, and G4OpenGLStoredSceneHandler.

Definition at line 314 of file G4OpenGLSceneHandler.cc.

315{
316 G4VSceneHandler::EndPrimitives ();
317}
G4VSceneHandler::EndPrimitives
virtual void EndPrimitives()
Definition G4VSceneHandler.cc:178

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

◆ EndPrimitives2D()

void G4OpenGLSceneHandler::EndPrimitives2D ( )
virtual

Reimplemented from G4VSceneHandler.

Reimplemented in G4OpenGLImmediateSceneHandler, and G4OpenGLStoredSceneHandler.

Definition at line 331 of file G4OpenGLSceneHandler.cc.

332{
333 G4VSceneHandler::EndPrimitives2D ();
334}
G4VSceneHandler::EndPrimitives2D
virtual void EndPrimitives2D()
Definition G4VSceneHandler.cc:201

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

◆ GetEntitiesFlushInterval()

G4int G4OpenGLSceneHandler::GetEntitiesFlushInterval ( )
inlinestatic

Definition at line 97 of file G4OpenGLSceneHandler.hh.

98 {return fEntitiesFlushInterval;}

◆ GetFlushAction()

FlushAction G4OpenGLSceneHandler::GetFlushAction ( )
inlinestatic

Definition at line 99 of file G4OpenGLSceneHandler.hh.

100 {return fFlushAction;}
G4OpenGLSceneHandler::fFlushAction
static FlushAction fFlushAction
Definition G4OpenGLSceneHandler.hh:125

◆ 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}
G4VSceneHandler::PreAddSolid
virtual void PreAddSolid(const G4Transform3D &objectTransformation, const G4VisAttributes &)
Definition G4VSceneHandler.cc:149

◆ ProcessScene()

void G4OpenGLSceneHandler::ProcessScene ( )
protectedvirtual

Reimplemented from G4VSceneHandler.

Definition at line 270 of file G4OpenGLSceneHandler.cc.

271{
272 fThreePassCapable = true;
273
274 G4VSceneHandler::ProcessScene();
275
276 // Repeat if required...
277 if (fSecondPassForTransparencyRequested) {
278 fSecondPassForTransparency = true;
279 G4VSceneHandler::ProcessScene();
280 fSecondPassForTransparency = false;
281 fSecondPassForTransparencyRequested = false;
282 }
283
284 // And again if required...
285 if (fThirdPassForNonHiddenMarkersRequested) {
286 fThirdPassForNonHiddenMarkers = true;
287 G4VSceneHandler::ProcessScene();
288 fThirdPassForNonHiddenMarkers = false;
289 fThirdPassForNonHiddenMarkersRequested = false;
290 }
291
292 fThreePassCapable = false;
293}
G4VSceneHandler::ProcessScene
virtual void ProcessScene()
Definition G4VSceneHandler.cc:673

◆ ScaledFlush()

void G4OpenGLSceneHandler::ScaledFlush ( )
protected

Definition at line 113 of file G4OpenGLSceneHandler.cc.

114{
115 if (fReadyForTransients) {
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 =
131 fpModel->GetModelingParameters();
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) {
141 fFlushAction = endOfRun;
142 } else if (fFlushAction == NthEvent) {
143 fFlushAction = NthPrimitive;
144 }
145 }
146 G4RunManager* runMan = G4RunManagerFactory::GetMasterRunManager();
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) {
156 fFlushAction = NthPrimitive;
157 } else if (fFlushAction == NthEvent) {
158 fFlushAction = NthPrimitive;
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.
166 if (!fpScene->GetRefreshAtEndOfEvent()) {
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.
181 if (!fpScene->GetRefreshAtEndOfRun()) {
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.
194 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.
208 if (!fpScene->GetRefreshAtEndOfEvent()) {
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.
248 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}
G4Event::GetEventID
G4int GetEventID() const
Definition G4Event.hh:126
G4ModelingParameters::GetEvent
const G4Event * GetEvent() const
G4RunManagerFactory::GetMasterRunManager
static G4RunManager * GetMasterRunManager()
Definition G4RunManagerFactory.cc:249
G4RunManager::GetCurrentRun
const G4Run * GetCurrentRun() const
Definition G4RunManager.hh:486
G4Run::GetRunID
G4int GetRunID() const
Definition G4Run.hh:82

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

◆ SetEntitiesFlushInterval()

void G4OpenGLSceneHandler::SetEntitiesFlushInterval ( G4int interval)
inlinestatic

Definition at line 101 of file G4OpenGLSceneHandler.hh.

102 {fEntitiesFlushInterval = interval;}

Referenced by G4OpenGLViewerMessenger::SetNewValue().

◆ SetFlushAction()

void G4OpenGLSceneHandler::SetFlushAction ( FlushAction action)
inlinestatic

Definition at line 103 of file G4OpenGLSceneHandler.hh.

104 {fFlushAction = action;}

Referenced by G4OpenGLViewerMessenger::SetNewValue().

◆ G4OpenGLViewer

friend class G4OpenGLViewer
friend

Definition at line 48 of file G4OpenGLSceneHandler.hh.

Referenced by AddPrimitive(), AddPrimitive(), AddPrimitive(), AddPrimitive(), G4OpenGLImmediateSceneHandler::BeginPrimitives2D(), and G4OpenGLViewer.

Member Data Documentation

◆ fEdgeFlag

bool G4OpenGLSceneHandler::fEdgeFlag
protected

Definition at line 139 of file G4OpenGLSceneHandler.hh.

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

◆ fEntitiesFlushInterval

G4int G4OpenGLSceneHandler::fEntitiesFlushInterval = 100
staticprotected

Definition at line 127 of file G4OpenGLSceneHandler.hh.

Referenced by GetEntitiesFlushInterval(), ScaledFlush(), and SetEntitiesFlushInterval().

◆ 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().

◆ fPickName

GLuint G4OpenGLSceneHandler::fPickName
protected

Definition at line 119 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLStoredSceneHandler::EndModeling(), and G4OpenGLSceneHandler().

◆ fSecondPassForTransparency

G4bool G4OpenGLSceneHandler::fSecondPassForTransparency
protected

Definition at line 133 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLSceneHandler(), and ProcessScene().

◆ fSecondPassForTransparencyRequested

G4bool G4OpenGLSceneHandler::fSecondPassForTransparencyRequested
protected

Definition at line 132 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLSceneHandler(), and 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 G4OpenGLSceneHandler(), and ProcessScene().

◆ fThirdPassForNonHiddenMarkersRequested

G4bool G4OpenGLSceneHandler::fThirdPassForNonHiddenMarkersRequested
protected

Definition at line 135 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLSceneHandler(), and ProcessScene().

◆ fThreePassCapable

G4bool G4OpenGLSceneHandler::fThreePassCapable
protected

Definition at line 130 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLSceneHandler(), and ProcessScene().

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