Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Static Protected Attributes | Friends | List of all members
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 ()
 

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 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
 

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:101

◆ ~G4OpenGLSceneHandler()

G4OpenGLSceneHandler::~G4OpenGLSceneHandler ( )
protectedvirtual

Definition at line 97 of file G4OpenGLSceneHandler.cc.

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

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 {
858 StandardSpecialMeshRendering(mesh);
859}
G4VSceneHandler::StandardSpecialMeshRendering
void StandardSpecialMeshRendering(const G4Mesh &)
Definition G4VSceneHandler.cc:1346

◆ 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}
G4VSceneHandler::AddCompound
virtual void AddCompound(const G4VTrajectory &)
Definition G4VSceneHandler.cc:325

◆ 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.
499 G4OpenGLSceneHandler::AddPrimitive(oneCircle);
500}
G4OpenGLSceneHandler::AddPrimitive
void AddPrimitive(const G4Polyline &)
Definition G4OpenGLSceneHandler.cc:342
G4VMarker::GetPosition
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}
G4warn
#define G4warn
Definition G4Scene.cc:41
G4endl
#define G4endl
Definition G4ios.hh:67
G4VGraphicsSystem::GetName
const G4String & GetName() const
Definition G4VGraphicsSystem.hh:79
G4VSceneHandler::fSystem
G4VGraphicsSystem & fSystem
Definition G4VSceneHandler.hh:434

◆ 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.
525 G4ViewParameters::DrawingStyle drawing_style = GetDrawingStyle (fpVisAttribs);
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
549 G4double lineWidth = GetLineWidth(fpVisAttribs);
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) {
560 case (G4ViewParameters::hlhsr):
561 // Set up as for hidden line removal but paint polygon faces later...
562 case (G4ViewParameters::hlr):
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;
592 case (G4ViewParameters::hsr):
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;
620 case (G4ViewParameters::wireframe):
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}
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:756
G4VSceneHandler::fpVisAttribs
const G4VisAttributes * fpVisAttribs
Definition G4VSceneHandler.hh:452
G4VSceneHandler::GetDrawingStyle
G4ViewParameters::DrawingStyle GetDrawingStyle(const G4VisAttributes *)
Definition G4VSceneHandler.cc:1168
G4VSceneHandler::GetLineWidth
G4double GetLineWidth(const G4VisAttributes *)
Definition G4VSceneHandler.cc:1158
G4VSceneHandler::GetAuxEdgeVisible
G4bool GetAuxEdgeVisible(const G4VisAttributes *)
Definition G4VSceneHandler.cc:1227
G4VViewer::fVP
G4ViewParameters fVP
Definition G4VViewer.hh:257
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 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
351 G4double lineWidth = GetLineWidth(fpVisAttribs);
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.
396 G4double lineWidth = GetLineWidth(fpVisAttribs);
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) {
405 case G4VMarker::noFill:
406 glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
407 glEdgeFlag (GL_TRUE);
408 //filled = false;
409 break;
410 case G4VMarker::hashed:
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...
420 case G4VMarker::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:
434 case G4Polymarker::dots:
435 size = 1.;
436 [[fallthrough]]; // Fall through to circles
437 case G4Polymarker::circles:
438 nSides = GetNoOfSides(fpVisAttribs);
439 startPhi = 0.;
440 break;
441 case G4Polymarker::squares:
442 nSides = 4;
443 startPhi = -pi / 4.;
444 break;
445 }
446
447 const G4Vector3D& viewpointDirection =
448 fpViewer -> GetViewParameters().GetViewpointDirection();
449 const G4Vector3D& up = fpViewer->GetViewParameters().GetUpVector();
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:
473 case G4Polymarker::dots:
474 case G4Polymarker::circles:
475 glEnable (GL_POINT_SMOOTH); break;
476 case G4Polymarker::squares:
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}
G4cout
G4GLOB_DLL std::ostream G4cout
G4OpenGLViewer::ChangePointSize
void ChangePointSize(G4double size)
Definition G4OpenGLViewer.cc:744
G4Polymarker::GetMarkerType
MarkerType GetMarkerType() const
G4VMarker::GetFillStyle
FillStyle GetFillStyle() const
G4VSceneHandler::GetNoOfSides
G4int GetNoOfSides(const G4VisAttributes *)
Definition G4VSceneHandler.cc:1259
G4VSceneHandler::GetMarkerSize
G4double GetMarkerSize(const G4VMarker &, MarkerSizeType &)
Definition G4VSceneHandler.cc:1236
G4VViewer::GetViewParameters
const G4ViewParameters & GetViewParameters() const
G4ViewParameters::GetUpVector
const G4Vector3D & GetUpVector() const
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

◆ 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.
507 G4OpenGLSceneHandler::AddPrimitive(oneSquare);
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}
G4OpenGLViewer::DrawText
virtual void DrawText(const G4Text &)
Definition G4OpenGLViewer.cc:704

◆ 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}
G4VSceneHandler::BeginPrimitives
virtual void BeginPrimitives(const G4Transform3D &objectTransformation=G4Transform3D())
Definition G4VSceneHandler.cc:168

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}
G4VSceneHandler::BeginPrimitives2D
virtual void BeginPrimitives2D(const G4Transform3D &objectTransformation=G4Transform3D())
Definition G4VSceneHandler.cc:192

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 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{
326 return G4VSceneHandler::CreateSectionSolid();
327 // If clipping done in G4OpenGLViewer::SetView
328 // return 0;
329 // Note: if you change this, you must also change
330 // G4OpenGLStoredViewer::CompareForKernelVisit
331}
G4VSceneHandler::CreateSectionSolid
virtual G4DisplacedSolid * CreateSectionSolid()
Definition G4VSceneHandler.cc:976

◆ EndPrimitives()

void G4OpenGLSceneHandler::EndPrimitives ( )
virtual

Reimplemented from G4VSceneHandler.

Reimplemented in G4OpenGLImmediateSceneHandler, and G4OpenGLStoredSceneHandler.

Definition at line 308 of file G4OpenGLSceneHandler.cc.

309{
310 G4VSceneHandler::EndPrimitives ();
311}
G4VSceneHandler::EndPrimitives
virtual void EndPrimitives()
Definition G4VSceneHandler.cc:180

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

◆ EndPrimitives2D()

void G4OpenGLSceneHandler::EndPrimitives2D ( )
virtual

Reimplemented from G4VSceneHandler.

Reimplemented in G4OpenGLImmediateSceneHandler, and G4OpenGLStoredSceneHandler.

Definition at line 319 of file G4OpenGLSceneHandler.cc.

320{
321 G4VSceneHandler::EndPrimitives2D ();
322}
G4VSceneHandler::EndPrimitives2D
virtual void EndPrimitives2D()
Definition G4VSceneHandler.cc:203

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

◆ GetEntitiesFlushInterval()

static G4int G4OpenGLSceneHandler::GetEntitiesFlushInterval ( )
inlinestatic

Definition at line 97 of file G4OpenGLSceneHandler.hh.

98 {return fEntitiesFlushInterval;}

◆ GetFlushAction()

static 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:151

◆ 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:677

◆ 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:123
G4ModelingParameters::GetEvent
const G4Event * GetEvent() const
G4RunManagerFactory::GetMasterRunManager
static G4RunManager * GetMasterRunManager()
Definition G4RunManagerFactory.cc:230
G4RunManager::GetCurrentRun
const G4Run * GetCurrentRun() const
Definition G4RunManager.hh:483
G4Run
Definition G4Run.hh:49
G4Run::GetRunID
G4int GetRunID() const
Definition G4Run.hh:86
G4Scene::GetRefreshAtEndOfEvent
G4bool GetRefreshAtEndOfEvent() const
G4Scene::GetRefreshAtEndOfRun
G4bool GetRefreshAtEndOfRun() const
G4VModel::GetModelingParameters
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

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(), and G4OpenGLViewer::GetPickDetails().

◆ fPickName

GLuint G4OpenGLSceneHandler::fPickName
protected

Definition at line 119 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLStoredSceneHandler::EndModeling(), G4OpenGLStoredSceneHandler::PO::operator=(), and G4OpenGLStoredSceneHandler::TO::operator=().

◆ 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: