#include <G4OpenGLStoredViewer.hh>

Inheritance diagram for G4OpenGLStoredViewer:

Public Member Functions
	G4OpenGLStoredViewer (G4OpenGLStoredSceneHandler &scene)

virtual	~G4OpenGLStoredViewer ()

Public Member Functions inherited from G4OpenGLViewer
virtual void	ClearView ()

void	ClearViewWithoutFlush ()

virtual bool	exportImage (std::string name="", int width=-1, int height=-1)

bool	setExportImageFormat (std::string format, bool quiet=false)

Public Member Functions inherited from G4VViewer
	G4VViewer (G4VSceneHandler &, G4int id, const G4String &name="")

virtual	~G4VViewer ()

virtual void	Initialise ()

virtual void	DrawView ()=0

void	RefreshView ()

virtual void	ShowView ()

virtual void	FinishView ()

virtual G4bool	ReadyToDraw ()

std::vector< G4ThreeVector >	ComputeFlyThrough (G4Vector3D *)

virtual void	DoneWithMasterThread ()

virtual void	MovingToVisSubThread ()

virtual void	SwitchToVisSubThread ()

virtual void	DoneWithVisSubThread ()

virtual void	MovingToMasterThread ()

virtual void	SwitchToMasterThread ()

void	InsertModelInSceneTree (G4VModel *)

const G4SceneTreeItem &	GetSceneTree ()

G4SceneTreeItem &	AccessSceneTree ()

void	UpdateGUISceneTree ()

const G4String &	GetName () const

const G4String &	GetShortName () const

void	SetName (const G4String &)

G4int	GetViewId () const

G4VSceneHandler *	GetSceneHandler () const

const G4ViewParameters &	GetViewParameters () const

const G4ViewParameters &	GetDefaultViewParameters () const

G4double	GetKernelVisitElapsedTimeSeconds () const

virtual const std::vector< G4ModelingParameters::VisAttributesModifier > *	GetPrivateVisAttributesModifiers () const

void	SetViewParameters (const G4ViewParameters &vp)

void	SetDefaultViewParameters (const G4ViewParameters &vp)

const G4VisAttributes *	GetApplicableVisAttributes (const G4VisAttributes *) const

void	SetNeedKernelVisit (G4bool need)

void	NeedKernelVisit ()

void	ProcessView ()

Protected Member Functions
void	KernelVisitDecision ()

virtual G4bool	CompareForKernelVisit (G4ViewParameters &)

void	DrawDisplayLists ()

virtual void	DisplayTimePOColourModification (G4Colour &, size_t)

void	AddPrimitiveForASingleFrame (const G4Text &text)

void	AddPrimitiveForASingleFrame (const G4Circle &circle)

virtual G4bool	POSelected (size_t)

virtual G4bool	TOSelected (size_t)

Protected Member Functions inherited from G4OpenGLViewer
	G4OpenGLViewer (G4OpenGLSceneHandler &scene)

virtual	~G4OpenGLViewer ()

virtual void	SetView ()

virtual void	ResetView ()

virtual void	DrawText (const G4Text &)

void	ChangePointSize (G4double size)

void	ChangeLineWidth (G4double width)

void	HaloingFirstPass ()

void	HaloingSecondPass ()

void	HLRFirstPass ()

void	HLRSecondPass ()

void	HLRThirdPass ()

void	InitializeGLView ()

void	ResizeGLView ()

void	ResizeWindow (unsigned int, unsigned int)

virtual G4String	Pick (GLdouble x, GLdouble y)

const std::vector< G4OpenGLViewerPickMap * > &	GetPickDetails (GLdouble x, GLdouble y)

virtual void	CreateFontLists ()

void	rotateScene (G4double dx, G4double dy)

void	rotateSceneToggle (G4double dx, G4double dy)

void	setExportSize (G4int, G4int)

bool	setExportFilename (G4String name, G4bool inc=true)

std::string	getRealPrintFilename ()

unsigned int	getWinWidth () const

unsigned int	getWinHeight () const

G4bool	sizeHasChanged ()

GLdouble	getSceneNearWidth ()

GLdouble	getSceneFarWidth ()

GLdouble	getSceneDepth ()

void	addExportImageFormat (std::string format)

G4bool	isGl2psWriting ()

G4bool	isFramebufferReady ()

void	g4GluPickMatrix (GLdouble x, GLdouble y, GLdouble width, GLdouble height, GLint viewport[4])

void	g4GluLookAt (GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz)

void	g4GlOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)

void	g4GlFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)

bool	IsGettingPickInfos () const

Protected Member Functions inherited from G4VViewer
void	SetTouchable (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath)

void	TouchableSetVisibility (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, G4bool visibility)

void	TouchableSetColour (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, const G4Colour &)

Protected Attributes
G4OpenGLStoredSceneHandler &	fG4OpenGLStoredSceneHandler

G4ViewParameters	fLastVP

G4bool	fDepthTestEnable

G4Colour	fOldDisplayListColor

Protected Attributes inherited from G4OpenGLViewer
G4bool	fPrintColour

G4bool	fVectoredPs

G4OpenGLSceneHandler &	fOpenGLSceneHandler

G4Colour	background

G4bool	transparency_enabled

G4bool	antialiasing_enabled

G4bool	haloing_enabled

G4gl2ps *	fGL2PSAction

G4double	fRot_sens

G4double	fPan_sens

unsigned int	fWinSize_x

unsigned int	fWinSize_y

std::vector< std::string >	fExportImageFormatVector

std::string	fDefaultExportImageFormat

std::string	fExportImageFormat

int	fExportFilenameIndex

G4int	fPrintSizeX

G4int	fPrintSizeY

Protected Attributes inherited from G4VViewer
G4VSceneHandler &	fSceneHandler

G4int	fViewId

G4String	fName

G4String	fShortName

G4ViewParameters	fVP

G4ViewParameters	fDefaultVP

G4double	fKernelVisitElapsedTimeSeconds = 999.

G4SceneTreeItem	fSceneTree

G4bool	fNeedKernelVisit

Additional Inherited Members
Public Attributes inherited from G4VViewer
const G4int	fMaxNTouchables = 10000

G4bool	fCurtailDescent = false

Detailed Description

Definition at line 44 of file G4OpenGLStoredViewer.hh.

Constructor & Destructor Documentation

◆ G4OpenGLStoredViewer()

G4OpenGLStoredViewer::G4OpenGLStoredViewer ( G4OpenGLStoredSceneHandler & scene )

Definition at line 44 of file G4OpenGLStoredViewer.cc.

                                          :
G4VViewer (sceneHandler, -1),
G4OpenGLViewer (sceneHandler),
fG4OpenGLStoredSceneHandler (sceneHandler),
fDepthTestEnable(true)
{
  fLastVP = fDefaultVP;  // Update in sub-class after KernelVisitDecision
}

Referenced by G4OpenGLStoredQtViewer::G4OpenGLStoredQtViewer(), G4OpenGLStoredWin32Viewer::G4OpenGLStoredWin32Viewer(), G4OpenGLStoredXmViewer::G4OpenGLStoredXmViewer(), and G4OpenGLStoredXViewer::G4OpenGLStoredXViewer().

◆ ~G4OpenGLStoredViewer()

G4OpenGLStoredViewer::~G4OpenGLStoredViewer ( )

virtual

Definition at line 54 of file G4OpenGLStoredViewer.cc.

54{}

Member Function Documentation

◆ AddPrimitiveForASingleFrame() [1/2]

void G4OpenGLStoredViewer::AddPrimitiveForASingleFrame ( const G4Circle & circle )

protected

Definition at line 487 of file G4OpenGLStoredViewer.cc.

{
  // We don't want this to get into a display list or a TODL or a PODL so
  // use the fMemoryForDisplayLists flag.
  fG4OpenGLStoredSceneHandler.fDoNotUseDisplayList = true;
  fG4OpenGLStoredSceneHandler.G4OpenGLStoredSceneHandler::AddPrimitive(circle);
  fG4OpenGLStoredSceneHandler.fDoNotUseDisplayList = false;
}

◆ AddPrimitiveForASingleFrame() [2/2]

void G4OpenGLStoredViewer::AddPrimitiveForASingleFrame ( const G4Text & text )

protected

Definition at line 478 of file G4OpenGLStoredViewer.cc.

{
  // We don't want this to get into a display list or a TODL or a PODL so
  // use the fMemoryForDisplayLists flag.
  fG4OpenGLStoredSceneHandler.fDoNotUseDisplayList = true;
  fG4OpenGLStoredSceneHandler.G4OpenGLStoredSceneHandler::AddPrimitive(text);
  fG4OpenGLStoredSceneHandler.fDoNotUseDisplayList = false;
}

Referenced by DrawDisplayLists().

◆ CompareForKernelVisit()

G4bool G4OpenGLStoredViewer::CompareForKernelVisit ( G4ViewParameters & lastVP )

protectedvirtual

Reimplemented in G4OpenGLStoredQtViewer.

Definition at line 67 of file G4OpenGLStoredViewer.cc.

                                                                           {
  
  if (
      (lastVP.GetDrawingStyle ()    != fVP.GetDrawingStyle ())    ||
      (lastVP.GetNumberOfCloudPoints()  != fVP.GetNumberOfCloudPoints())  ||
      (lastVP.IsAuxEdgeVisible ()   != fVP.IsAuxEdgeVisible ())   ||
      (lastVP.IsCulling ()          != fVP.IsCulling ())          ||
      (lastVP.IsCullingInvisible () != fVP.IsCullingInvisible ()) ||
      (lastVP.IsDensityCulling ()   != fVP.IsDensityCulling ())   ||
      (lastVP.IsCullingCovered ()   != fVP.IsCullingCovered ())   ||
      (lastVP.GetCBDAlgorithmNumber() !=
       fVP.GetCBDAlgorithmNumber())                               ||
      // Note: Section and Cutaway can reveal back-facing faces. If
      // backface culling is implemented, the image can look strange because
      // the back-facing faces are not there. For the moment, we have disabled
      // (commented out) backface culling (it seems not to affect performance -
      // in fact, performance seems to improve), so there is no problem.
      (lastVP.IsSection ()          != fVP.IsSection ())          ||
      // Section (DCUT) is NOT implemented locally so we need to visit the kernel.
      // (lastVP.IsCutaway ()          != fVP.IsCutaway ())          ||
      // Cutaways are implemented locally so we do not need to visit the kernel.
      (lastVP.IsExplode ()          != fVP.IsExplode ())          ||
      (lastVP.GetNoOfSides ()       != fVP.GetNoOfSides ())       ||
      (lastVP.GetGlobalMarkerScale()    != fVP.GetGlobalMarkerScale())    ||
      (lastVP.GetGlobalLineWidthScale() != fVP.GetGlobalLineWidthScale()) ||
      (lastVP.IsMarkerNotHidden ()  != fVP.IsMarkerNotHidden ())  ||
      (lastVP.GetDefaultVisAttributes()->GetColour() !=
       fVP.GetDefaultVisAttributes()->GetColour())                ||
      (lastVP.GetDefaultTextVisAttributes()->GetColour() !=
       fVP.GetDefaultTextVisAttributes()->GetColour())            ||
      (lastVP.GetBackgroundColour ()!= fVP.GetBackgroundColour ())||
      (lastVP.IsPicking ()          != fVP.IsPicking ())          ||
      (lastVP.GetVisAttributesModifiers() !=
       fVP.GetVisAttributesModifiers())                           ||
      (lastVP.IsSpecialMeshRendering() !=
       fVP.IsSpecialMeshRendering())                              ||
      (lastVP.GetSpecialMeshRenderingOption() !=
       fVP.GetSpecialMeshRenderingOption())
      )
  return true;
  
  if (lastVP.IsDensityCulling () &&
      (lastVP.GetVisibleDensity () != fVP.GetVisibleDensity ()))
  return true;
  
//  /**************************************************************
//   If section (DCUT) is implemented locally, comment this out.
  if (lastVP.IsSection () &&
      (lastVP.GetSectionPlane () != fVP.GetSectionPlane ()))
    return true;
//   ***************************************************************/
  
  /**************************************************************
   If cutaways are implemented locally, comment this out.
   if (lastVP.IsCutaway ()) {
   if (vp.GetCutawayMode() != fVP.GetCutawayMode()) return true;
   if (lastVP.GetCutawayPlanes ().size () !=
   fVP.GetCutawayPlanes ().size ()) return true;
   for (size_t i = 0; i < lastVP.GetCutawayPlanes().size(); ++i)
   if (lastVP.GetCutawayPlanes()[i] != fVP.GetCutawayPlanes()[i])
   return true;
   }
   ***************************************************************/
  
  if (lastVP.GetCBDAlgorithmNumber() > 0) {
    if (lastVP.GetCBDParameters().size() != fVP.GetCBDParameters().size()) return true;
    else if (lastVP.GetCBDParameters() != fVP.GetCBDParameters()) return true;
  }
 
  if (lastVP.IsExplode () &&
      (lastVP.GetExplodeFactor () != fVP.GetExplodeFactor ()))
    return true;
 
  if (lastVP.IsSpecialMeshRendering() &&
      (lastVP.GetSpecialMeshVolumes() != fVP.GetSpecialMeshVolumes()))
    return true;
 
  // Time window parameters operate on the existing database so no need
  // to rebuild even if they change.
  
  return false;
}

Referenced by KernelVisitDecision().

◆ DisplayTimePOColourModification()

virtual void G4OpenGLStoredViewer::DisplayTimePOColourModification	(	G4Colour &	,
		size_t	)

inlineprotectedvirtual

Reimplemented in G4OpenGLStoredQtViewer.

Definition at line 56 of file G4OpenGLStoredViewer.hh.

57{}

Referenced by DrawDisplayLists().

◆ DrawDisplayLists()

void G4OpenGLStoredViewer::DrawDisplayLists ( )

protected

Definition at line 150 of file G4OpenGLStoredViewer.cc.

                                             {
  
  // We moved these from G4OpenGLViewer to G4ViewParamaters. To avoid
  // editing many lines below we introduce these convenient aliases.
#define CONVENIENT_DOUBLE_ALIAS(q) const G4double& f##q = fVP.Get##q();
#define CONVENIENT_BOOL_ALIAS(q) const G4bool& f##q = fVP.Is##q();
  CONVENIENT_DOUBLE_ALIAS(StartTime)
  CONVENIENT_DOUBLE_ALIAS(EndTime)
  CONVENIENT_DOUBLE_ALIAS(FadeFactor)
  CONVENIENT_BOOL_ALIAS(DisplayHeadTime)
  CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeX)
  CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeY)
  CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeSize)
  CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeRed)
  CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeGreen)
  CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeBlue)
  CONVENIENT_BOOL_ALIAS(DisplayLightFront)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontX)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontY)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontZ)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontT)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontRed)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontGreen)
  CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontBlue)
 
  const G4Planes& cutaways = fVP.GetCutawayPlanes();
  G4bool cutawayUnion = fVP.IsCutaway() &&
  fVP.GetCutawayMode() == G4ViewParameters::cutawayUnion;
  const size_t nCutaways = cutawayUnion? cutaways.size(): 1;
  G4int iPass = 1;
  G4bool secondPassForTransparencyRequested = false;
  G4bool thirdPassForNonHiddenMarkersRequested = false;
  fDepthTestEnable = true;
  glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LEQUAL);
  do {
    for (size_t iCutaway = 0; iCutaway < nCutaways; ++iCutaway) {
      
      if (cutawayUnion) {
        double a[4];
        a[0] = cutaways[iCutaway].a();
        a[1] = cutaways[iCutaway].b();
        a[2] = cutaways[iCutaway].c();
        a[3] = cutaways[iCutaway].d();
        glClipPlane (GL_CLIP_PLANE2, a);
        glEnable (GL_CLIP_PLANE2);
      }
      
      G4bool isPicking = fVP.IsPicking();
      
      for (size_t iPO = 0;
           iPO < fG4OpenGLStoredSceneHandler.fPOList.size(); ++iPO) {
        if (POSelected(iPO)) {
          G4OpenGLStoredSceneHandler::PO& po =
          fG4OpenGLStoredSceneHandler.fPOList[iPO];
          G4Colour c = po.fColour;
          DisplayTimePOColourModification(c,iPO);
          const G4bool isTransparent = c.GetAlpha() < 1.;
          if ( iPass == 1) {
            if (isTransparent && transparency_enabled) {
              secondPassForTransparencyRequested = true;
              continue;
            }
            if (po.fMarkerOrPolyline && fVP.IsMarkerNotHidden()) {
              thirdPassForNonHiddenMarkersRequested = true;
              continue;
            }
          } else if (iPass == 2) {  // Second pass for transparency.
            if (!isTransparent) {
              continue;
            }
          } else {  // Third pass for non-hidden markers
            if (!po.fMarkerOrPolyline) {
              continue;
            }
          }
          if (isPicking) glLoadName(po.fPickName);
          if (transparency_enabled) {
            glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha());
          } else {
            glColor3d(c.GetRed(),c.GetGreen(),c.GetBlue());
          }
          if (po.fMarkerOrPolyline && fVP.IsMarkerNotHidden()) {
            if (fDepthTestEnable !=false) {
              glDisable (GL_DEPTH_TEST);
              fDepthTestEnable = false;
            }
          } else {
            if (fDepthTestEnable !=true) {
              glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LEQUAL);
              fDepthTestEnable = true;
            }
          }
          if (po.fpG4TextPlus) {
            if (po.fpG4TextPlus->fProcessing2D) {
              glMatrixMode (GL_PROJECTION);
              glPushMatrix();
              glLoadIdentity();
              g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
              glMatrixMode (GL_MODELVIEW);
              glPushMatrix();
              glLoadIdentity();
              G4OpenGLTransform3D oglt (po.fTransform);
              glMultMatrixd (oglt.GetGLMatrix ());
              // This text is from a PODL. We don't want to create a new PODL.
              AddPrimitiveForASingleFrame(po.fpG4TextPlus->fG4Text);
            } else {
              glPushMatrix();
              G4OpenGLTransform3D oglt (po.fTransform);
              glMultMatrixd (oglt.GetGLMatrix ());
              // This text is from a PODL. We don't want to create a new PODL.
              AddPrimitiveForASingleFrame(po.fpG4TextPlus->fG4Text);
              glPopMatrix();
            }
            
            if (po.fpG4TextPlus->fProcessing2D) {
              glMatrixMode (GL_PROJECTION);
              glPopMatrix();
              glMatrixMode (GL_MODELVIEW);
              glPopMatrix();
            }
          } else {
            glPushMatrix();
            G4OpenGLTransform3D oglt (po.fTransform);
            glMultMatrixd (oglt.GetGLMatrix ());
            glCallList (po.fDisplayListId);
            glPopMatrix();
          }
        }
      }
      
      G4Transform3D lastMatrixTransform;
      G4bool first = true;
 
      for (size_t iTO = 0;
           iTO < fG4OpenGLStoredSceneHandler.fTOList.size(); ++iTO) {
        if (TOSelected(iTO)) {
          G4OpenGLStoredSceneHandler::TO& to =
          fG4OpenGLStoredSceneHandler.fTOList[iTO];
          const G4Colour& c = to.fColour;
          const G4bool isTransparent = c.GetAlpha() < 1.;
          if ( iPass == 1) {
            if (isTransparent && transparency_enabled) {
              secondPassForTransparencyRequested = true;
              continue;
            }
            if (to.fMarkerOrPolyline && fVP.IsMarkerNotHidden()) {
              thirdPassForNonHiddenMarkersRequested = true;
              continue;
            }
          } else if (iPass == 2) {  // Second pass for transparency.
            if (!isTransparent) {
              continue;
            }
          } else {  // Third pass for non-hidden markers
            if (!to.fMarkerOrPolyline) {
              continue;
            }
          }
          if (to.fMarkerOrPolyline && fVP.IsMarkerNotHidden()) {
            if (fDepthTestEnable !=false) {
              glDisable (GL_DEPTH_TEST);
              fDepthTestEnable = false;
            }
          } else {
            if (fDepthTestEnable !=true) {
              glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LEQUAL);
              fDepthTestEnable = true;
            }
          }
          if (to.fEndTime >= fStartTime && to.fStartTime <= fEndTime) {
            if (fVP.IsPicking()) glLoadName(to.fPickName);
            if (to.fpG4TextPlus) {
              if (to.fpG4TextPlus->fProcessing2D) {
                glMatrixMode (GL_PROJECTION);
                glPushMatrix();
                glLoadIdentity();
                g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
                glMatrixMode (GL_MODELVIEW);
                glPushMatrix();
                glLoadIdentity();
              }
              G4OpenGLTransform3D oglt (to.fTransform);
              glMultMatrixd (oglt.GetGLMatrix ());
              // This text is from a TODL. We don't want to create a new TODL.
              AddPrimitiveForASingleFrame(to.fpG4TextPlus->fG4Text);
              if (to.fpG4TextPlus->fProcessing2D) {
                glMatrixMode (GL_PROJECTION);
                glPopMatrix();
                glMatrixMode (GL_MODELVIEW);
                glPopMatrix();
              }
            } else {
              if (to.fTransform != lastMatrixTransform) {
                if (! first) {
                  glPopMatrix();
                }
                first = false;
                glPushMatrix();
                G4OpenGLTransform3D oglt (to.fTransform);
                glMultMatrixd (oglt.GetGLMatrix ());
              }
              const G4Colour& cc = to.fColour;
              if (fFadeFactor > 0. && to.fEndTime < fEndTime) {
                // Brightness scaling factor
                G4double bsf = 1. - fFadeFactor *
                ((fEndTime - to.fEndTime) / (fEndTime - fStartTime));
                const G4Colour& bg = fVP.GetBackgroundColour();
                if (transparency_enabled) {
                  glColor4d
                  (bsf * cc.GetRed() + (1. - bsf) * bg.GetRed(),
                   bsf * cc.GetGreen() + (1. - bsf) * bg.GetGreen(),
                   bsf * cc.GetBlue() + (1. - bsf) * bg.GetBlue(),
                   bsf * cc.GetAlpha() + (1. - bsf) * bg.GetAlpha());
                } else {
                  glColor3d
                  (bsf * cc.GetRed() + (1. - bsf) * bg.GetRed(),
                   bsf * cc.GetGreen() + (1. - bsf) * bg.GetGreen(),
                   bsf * cc.GetBlue() + (1. - bsf) * bg.GetBlue());
                }
              } else {
                if (transparency_enabled) {
                  glColor4d(cc.GetRed(),cc.GetGreen(),cc.GetBlue(),cc.GetAlpha());
                } else {
                  glColor3d(cc.GetRed(),cc.GetGreen(),cc.GetBlue());
                }
              }
              glCallList (to.fDisplayListId);
            }
            if (to.fTransform != lastMatrixTransform) {
              lastMatrixTransform = to.fTransform;
            }
          }
        }
      }
      if (! first) {
        glPopMatrix();
      }
      
      if (cutawayUnion) glDisable (GL_CLIP_PLANE2);
    }  // iCutaway
    
    if (iPass == 2) secondPassForTransparencyRequested = false;  // Done.
    if (iPass == 3) thirdPassForNonHiddenMarkersRequested = false;  // Done.
    
    if (secondPassForTransparencyRequested) iPass = 2;
    else if (thirdPassForNonHiddenMarkersRequested) iPass = 3;
    else break;
    
  } while (true);
  
  // Display time at "head" of time range, which is fEndTime...
  if (fDisplayHeadTime && fEndTime < G4VisAttributes::fVeryLongTime) {
    glMatrixMode (GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
    glMatrixMode (GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    G4Text headTimeText(G4BestUnit(fEndTime,"Time"),
                        G4Point3D(fDisplayHeadTimeX, fDisplayHeadTimeY, 0.));
    headTimeText.SetScreenSize(fDisplayHeadTimeSize);
    G4VisAttributes visAtts (G4Colour
                             (fDisplayHeadTimeRed,
                              fDisplayHeadTimeGreen,
                              fDisplayHeadTimeBlue));
    headTimeText.SetVisAttributes(&visAtts);
    AddPrimitiveForASingleFrame(headTimeText);
    glMatrixMode (GL_PROJECTION);
    glPopMatrix();
    glMatrixMode (GL_MODELVIEW);
    glPopMatrix();
  }
  
  // Display light front...
  if (fDisplayLightFront && fEndTime < G4VisAttributes::fVeryLongTime) {
    G4double lightFrontRadius = (fEndTime - fDisplayLightFrontT) * c_light;
    if (lightFrontRadius > 0.) {
      G4Point3D lightFrontCentre(fDisplayLightFrontX, fDisplayLightFrontY, fDisplayLightFrontZ);
      G4Point3D circleCentre = lightFrontCentre;
      G4double circleRadius = lightFrontRadius;
      if (fVP.GetFieldHalfAngle() > 0.) {
        // Perspective view.  Find horizon centre and radius...
        G4Point3D targetPoint = fSceneHandler.GetScene()->GetStandardTargetPoint() +
        fVP.GetCurrentTargetPoint();
        G4double sceneRadius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
        if(sceneRadius <= 0.) sceneRadius = 1.;
        G4double cameraDistance = fVP.GetCameraDistance(sceneRadius);
        G4Point3D cameraPosition = targetPoint + cameraDistance * fVP.GetViewpointDirection().unit();
        G4Vector3D lightFrontToCameraDirection = cameraPosition - lightFrontCentre;
        G4double lightFrontCentreDistance = lightFrontToCameraDirection.mag();
        /*
         G4cout << "cameraPosition: " << cameraPosition
         << ", lightFrontCentre: " << lightFrontCentre
         << ", lightFrontRadius: " << lightFrontRadius
         << ", lightFrontCentreDistance: " << lightFrontCentreDistance
         << ", dot: " << lightFrontToCameraDirection * fVP.GetViewpointDirection()
         << G4endl;
         */
        if (lightFrontToCameraDirection * fVP.GetViewpointDirection() > 0. && lightFrontRadius < lightFrontCentreDistance) {
          // Light front in front of camera...
          G4double sineHorizonAngle = lightFrontRadius / lightFrontCentreDistance;
          circleCentre = lightFrontCentre + (lightFrontRadius * sineHorizonAngle) * lightFrontToCameraDirection.unit();
          circleRadius = lightFrontRadius * std::sqrt(1. - std::pow(sineHorizonAngle, 2));
          /*
           G4cout << "sineHorizonAngle: " << sineHorizonAngle
           << ", circleCentre: " << circleCentre
           << ", circleRadius: " << circleRadius
           << G4endl;
           */
        } else {
          circleRadius = -1.;
        }
      }
      if (circleRadius > 0.) {
        G4Circle lightFront(circleCentre);
        lightFront.SetWorldRadius(circleRadius);
        G4VisAttributes visAtts(G4Colour
         (fDisplayLightFrontRed,
          fDisplayLightFrontGreen,
          fDisplayLightFrontBlue));
        lightFront.SetVisAttributes(visAtts);
        AddPrimitiveForASingleFrame(lightFront);
      }
    }
  }
}

Referenced by G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), and G4OpenGLStoredXViewer::DrawView().

◆ KernelVisitDecision()

void G4OpenGLStoredViewer::KernelVisitDecision ( )

protected

Definition at line 56 of file G4OpenGLStoredViewer.cc.

                                                {
  
  // If there's a significant difference with the last view parameters
  // of either the scene handler or this viewer, trigger a rebuild.
  
  if (!fG4OpenGLStoredSceneHandler.fTopPODL ||
      CompareForKernelVisit(fLastVP)) {
    NeedKernelVisit ();
  }
}

Referenced by G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), and G4OpenGLStoredXViewer::DrawView().

◆ POSelected()

virtual G4bool G4OpenGLStoredViewer::POSelected ( size_t )

inlineprotectedvirtual

Reimplemented in G4OpenGLStoredQtViewer.

Definition at line 67 of file G4OpenGLStoredViewer.hh.

67{return true;}

Referenced by DrawDisplayLists().

◆ TOSelected()

virtual G4bool G4OpenGLStoredViewer::TOSelected ( size_t )

inlineprotectedvirtual

Reimplemented in G4OpenGLStoredQtViewer.

Definition at line 68 of file G4OpenGLStoredViewer.hh.

68{return true;}

Referenced by DrawDisplayLists().

Member Data Documentation

◆ fDepthTestEnable

G4bool G4OpenGLStoredViewer::fDepthTestEnable

protected

Definition at line 70 of file G4OpenGLStoredViewer.hh.

Referenced by DrawDisplayLists(), and G4OpenGLStoredViewer().

◆ fG4OpenGLStoredSceneHandler

G4OpenGLStoredSceneHandler& G4OpenGLStoredViewer::fG4OpenGLStoredSceneHandler

protected

Definition at line 62 of file G4OpenGLStoredViewer.hh.

Referenced by AddPrimitiveForASingleFrame(), AddPrimitiveForASingleFrame(), DrawDisplayLists(), G4OpenGLStoredViewer(), and KernelVisitDecision().

◆ fLastVP

G4ViewParameters G4OpenGLStoredViewer::fLastVP

protected

Definition at line 64 of file G4OpenGLStoredViewer.hh.

Referenced by G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4OpenGLStoredViewer(), and KernelVisitDecision().

◆ fOldDisplayListColor

G4Colour G4OpenGLStoredViewer::fOldDisplayListColor

protected

Definition at line 71 of file G4OpenGLStoredViewer.hh.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4OpenGLStoredViewer()

◆ ~G4OpenGLStoredViewer()

Member Function Documentation

◆ AddPrimitiveForASingleFrame() [1/2]

◆ AddPrimitiveForASingleFrame() [2/2]

◆ CompareForKernelVisit()

◆ DisplayTimePOColourModification()

◆ DrawDisplayLists()

◆ KernelVisitDecision()

◆ POSelected()

◆ TOSelected()

Member Data Documentation

◆ fDepthTestEnable

◆ fG4OpenGLStoredSceneHandler

◆ fLastVP

◆ fOldDisplayListColor