G4OpenGLXViewer Class Reference

#include <G4OpenGLXViewer.hh>

Inheritance diagram for G4OpenGLXViewer:

Public Member Functions
	G4OpenGLXViewer (G4OpenGLSceneHandler &scene)
virtual	~G4OpenGLXViewer ()
void	SetView ()
void	ShowView ()
void	SwitchToVisSubThread ()
void	SwitchToMasterThread ()
void	DrawText (const G4Text &)
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	FinishView ()
virtual G4bool	ReadyToDraw ()
std::vector< G4ThreeVector >	ComputeFlyThrough (G4Vector3D *)
virtual void	DoneWithMasterThread ()
virtual void	MovingToVisSubThread ()
virtual void	DoneWithVisSubThread ()
virtual void	MovingToMasterThread ()
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	GetXConnection ()
void	CreateGLXContext (XVisualInfo *vi)
virtual void	CreateMainWindow ()
virtual void	CreateFontLists ()
Protected Member Functions inherited from G4OpenGLViewer
	G4OpenGLViewer (G4OpenGLSceneHandler &scene)
virtual	~G4OpenGLViewer ()
virtual void	ResetView ()
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)
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
XWindowAttributes	xwa
Display *	dpy
XVisualInfo *	vi_immediate
XVisualInfo *	vi_stored
XVisualInfo *	vi
Colormap	cmap
XSetWindowAttributes	swa
GLXDrawable	win
GLXContext	cxMaster
GLXContext	cxVisSubThread
XEvent	event
G4int *	attributeList
G4int	errorBase
G4int	eventBase
G4int	major
G4int	minor
XSizeHints *	norm_hints
XWMHints *	wm_hints
XClassHint *	class_hints
Pixmap	icon_pixmap
XSizeHints *	size_hints
Atom	Xatom
XTextProperty	windowName
XTextProperty	iconName
char	charViewName [100]
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

Static Protected Attributes
static int	snglBuf_RGBA [12]
static int	dblBuf_RGBA [13]
static XVisualInfo *	vi_single_buffer = 0
static XVisualInfo *	vi_double_buffer = 0

Friends
class	G4OpenGLXViewerMessenger
class	G4OpenGLXmViewer

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

Detailed Description

Definition at line 47 of file G4OpenGLXViewer.hh.

Constructor & Destructor Documentation

G4OpenGLXViewer()

G4OpenGLXViewer::G4OpenGLXViewer

(

G4OpenGLSceneHandler &

scene

)

Definition at line 450 of file G4OpenGLXViewer.cc.

                                                            :
G4VViewer (scene, -1),
G4OpenGLViewer (scene),
vi_immediate (0),
vi_stored (0),
vi (0),
cmap (0)
{
  // To satisfy Coverity
  xwa.visual = 0;
  iconName.value = 0;
  xwa.screen = 0;
  windowName.value = 0;
 
  GetXConnection ();
  if (fViewId < 0) return;
  
  // Try for a visual suitable for OpenGLImmediate..
  // first try for a single buffered RGB window
  if (!vi_single_buffer) {
    vi_single_buffer =
      glXChooseVisual (dpy, XDefaultScreen (dpy), snglBuf_RGBA);
    //G.Barrand : we should do a XFree(vi_single_buffer) at end;
  }
  if (!vi_double_buffer) {
    vi_double_buffer =
      glXChooseVisual (dpy, XDefaultScreen (dpy), dblBuf_RGBA);
    //G.Barrand : we should do a XFree(vi_double_buffer) at end;
  }
 
  if (vi_single_buffer || vi_double_buffer) {
    if (!vi_double_buffer) {
      G4cout <<
    "G4OpenGLXViewer::G4OpenGLXViewer: unable to get a double buffer visual."
    "\n  Working with a single buffer."
         << G4endl;
    }
  } else {
    if (!vi_single_buffer) {
      G4cout <<
    "G4OpenGLXViewer::G4OpenGLXViewer: unable to get a single buffer visual."
         << G4endl;
    }
    if (!vi_double_buffer) {
      G4cout <<
    "G4OpenGLXViewer::G4OpenGLXViewer: unable to get a double buffer visual."
         << G4endl;
    }
  }
 
  if (vi_single_buffer) {
    vi_immediate = vi_single_buffer;
    attributeList = snglBuf_RGBA;
  }
  
  if (!vi_immediate){
    // next try for a double buffered RGB, but Draw to top buffer
    if (vi_double_buffer) {
      vi_immediate = vi_double_buffer;
      attributeList = dblBuf_RGBA;
    }
  }
 
  // Now try for a visual suitable for OpenGLStored...
  // Try for a double buffered RGB window
  if (vi_double_buffer) {
    vi_stored = vi_double_buffer;
    attributeList = dblBuf_RGBA;
  }
 
  if (!vi_immediate || !vi_stored) {
    G4cout <<
    "G4OpenGLXViewer::G4OpenGLXViewer: unable to get required visuals."
       << G4endl;
    fViewId = -1;  // This flags an error.
  }
 
  //  glClearColor (0., 0., 0., 0.);
  //  glClearDepth (1.);
}

Referenced by G4OpenGLImmediateXViewer::G4OpenGLImmediateXViewer(), G4OpenGLStoredXViewer::G4OpenGLStoredXViewer(), G4OpenGLXmViewer::G4OpenGLXmViewer(), and G4OpenGLXmViewer::print_callback().

~G4OpenGLXViewer()

G4OpenGLXViewer::~G4OpenGLXViewer ( )

virtual

Definition at line 531 of file G4OpenGLXViewer.cc.

                                   {
  if (fViewId >= 0) {
    //Close a window from here
    glXMakeCurrent (dpy, None, NULL);
    glXDestroyContext (dpy, cxMaster);
    if (win) XDestroyWindow (dpy, win); // ...if already deleted in
    // sub-class G4OpenGLXmViewer.
    // We should do a XFreeColormap(dpy,cmap); if cmap had been get with XCreateColormap.
    XFlush (dpy);
  }
}

Member Function Documentation

CreateFontLists()

void G4OpenGLXViewer::CreateFontLists ( )

protectedvirtual

Reimplemented from G4OpenGLViewer.

Definition at line 345 of file G4OpenGLXViewer.cc.

{
  std::map<G4double,G4String> fonts;  // G4VMarker screen size and font name.
  fonts[10.] = "-adobe-courier-bold-r-normal--10-100-75-75-m-60-iso8859-1";
  fonts[11.] = "-adobe-courier-bold-r-normal--11-80-100-100-m-60-iso8859-1";
  fonts[12.] = "-adobe-courier-bold-r-normal--12-120-75-75-m-70-iso8859-1";
  fonts[13.] = "fixed";
  fonts[14.] = "-adobe-courier-bold-r-normal--14-100-100-100-m-90-iso8859-1";
  fonts[17.] = "-adobe-courier-bold-r-normal--17-120-100-100-m-100-iso8859-1";
  fonts[18.] = "-adobe-courier-bold-r-normal--18-180-75-75-m-110-iso8859-1";
  fonts[20.] = "-adobe-courier-bold-r-normal--20-140-100-100-m-110-iso8859-1";
  fonts[24.] = "-adobe-courier-bold-r-normal--24-240-75-75-m-150-iso8859-1";
  fonts[25.] = "-adobe-courier-bold-r-normal--25-180-100-100-m-150-iso8859-1";
  fonts[34.] = "-adobe-courier-bold-r-normal--34-240-100-100-m-200-iso8859-1";
  std::map<G4double,G4String>::const_iterator i;
  for (i = fonts.begin(); i != fonts.end(); ++i) {
    XFontStruct* font_info = XLoadQueryFont(dpy, i->second);
    if (!font_info) {
      G4cerr <<
    "G4OpenGLXViewer::CreateFontLists XLoadQueryFont failed for font\n  "
         << i->second
         << G4endl;
      continue;
    }
    G4int font_base = glGenLists(256);
    if (!font_base) {
      G4cerr <<
    "G4OpenGLXViewer::CreateFontLists out of display lists for fonts." 
         << G4endl;
      continue;
    }
    G4int first = font_info->min_char_or_byte2;
    G4int last  = font_info->max_char_or_byte2;
    glXUseXFont(font_info->fid, first, last-first+1, font_base + first);
    G4int width = font_info->max_bounds.width;
    G4OpenGLFontBaseStore::AddFontBase
      (this, font_base, i->first, i->second, width);
  }
}

Referenced by G4OpenGLImmediateXViewer::Initialise(), and G4OpenGLStoredXViewer::Initialise().

CreateGLXContext()

void G4OpenGLXViewer::CreateGLXContext ( XVisualInfo * vi )

protected

Definition at line 161 of file G4OpenGLXViewer.cc.

                                                      {
 
  vi = v;
// get window's attributes
  if (!XGetWindowAttributes(dpy, XRootWindow (dpy, vi -> screen), &xwa)) {
    fViewId = -1;  // This flags an error.
    G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer couldn't return window attributes"
     << G4endl;
    return;
  }
  
// create the master GLX context
  cxMaster = glXCreateContext (dpy, vi, 0, true);
  if (!cxMaster) {
    fViewId = -1;  // This flags an error.
    G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer couldn't create context."
     << G4endl;
    return;
  }
 
// New stab at getting a colormap
 
  Status status;
  int i, numCmaps;
 
  status = XmuLookupStandardColormap (dpy, 
                      vi -> screen, 
                      vi -> visualid, 
                      vi -> depth, 
                      XA_RGB_BEST_MAP,
                      False, 
                      True);
 
  if (status == 1) {
    cmap = 0;
    XStandardColormap* standardCmaps = XAllocStandardColormap ();
    status = XGetRGBColormaps (dpy, 
                   XRootWindow (dpy, vi -> screen),
                   &standardCmaps, 
                   &numCmaps, 
                   XA_RGB_BEST_MAP);
    if (status == 1) {
      for (i = 0; i < numCmaps; i++) {
    if (standardCmaps[i].visualid == vi -> visualid) {
      cmap = standardCmaps[i].colormap;
      break;
    }
      }
    }
    XFree (standardCmaps);
    if(cmap) {
      if (G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
        G4cout << "Got standard cmap" << G4endl;
    } else {
      //if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      //    G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer failed to allocate a standard colormap."
      //           << G4endl;
      cmap = XCreateColormap (dpy, 
                              XRootWindow(dpy, vi -> screen), 
                              vi -> visual, 
                              AllocNone);
      if(cmap) {
        if (G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
          G4cout << "Created own cmap" << G4endl;
      }
      //G.Barrand : at end, we should do a XFreeColormap(dpy,cmap) when cmap is no more used.
    }
  } else {
    cmap = XCreateColormap (dpy, 
                XRootWindow(dpy, vi -> screen), 
                vi -> visual, 
                AllocNone);
    if(cmap) {
      if (G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
        G4cout << "Created own cmap" << G4endl;
    }
    //G.Barrand : at end, we should do a XFreeColormap(dpy,cmap) when cmap is no more used.
  }
 
  if (!cmap) {
    fViewId = -1;  // This flags an error.
    if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "G4OpenGLXViewer::G4OpenGLXViewer failed to allocate a Colormap."
         << G4endl;
    return;
  }
 
}

Referenced by G4OpenGLImmediateXmViewer::Initialise(), G4OpenGLImmediateXViewer::Initialise(), G4OpenGLStoredXmViewer::Initialise(), and G4OpenGLStoredXViewer::Initialise().

CreateMainWindow()

void G4OpenGLXViewer::CreateMainWindow ( )

protectedvirtual

Reimplemented in G4OpenGLXmViewer.

Definition at line 250 of file G4OpenGLXViewer.cc.

                                        {
  
// create a window
  swa.colormap = cmap;
  swa.border_pixel = 0;
  swa.event_mask = ExposureMask | ButtonPressMask | StructureNotifyMask;
  swa.backing_store = WhenMapped;
 
  // Window size and position...
  size_hints = XAllocSizeHints();
    
  ResizeWindow(fVP.GetWindowSizeHintX(),fVP.GetWindowSizeHintY());
 
  G4int x_origin = fVP.GetWindowAbsoluteLocationHintX(DisplayWidth(dpy, vi -> screen));
 
  // FIXME,  screen size != window size on MAC, but I don't know have to get the menuBar
  // size on MAC. L.Garnier 01/2009
  G4int y_origin = fVP.GetWindowAbsoluteLocationHintY(DisplayHeight(dpy, vi -> screen));
 
  size_hints->base_width = getWinWidth();
  size_hints->base_height = getWinHeight();
  size_hints->x = x_origin;
  size_hints->y = y_origin;
  if (fVP.IsWindowSizeHintX () && fVP.IsWindowLocationHintX () && fVP.IsWindowLocationHintY ()) {
    size_hints->flags |= PSize | PPosition;
  } else if (fVP.IsWindowSizeHintX () && !(fVP.IsWindowLocationHintX () || fVP.IsWindowLocationHintY ())) {
    size_hints->flags |= PSize;
  } else if ((!fVP.IsWindowSizeHintX ()) && fVP.IsWindowLocationHintX () && fVP.IsWindowLocationHintY ()) {
    size_hints->flags |= PPosition;
  }
  if (G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "Window name: " << fName << G4endl;
  strncpy (charViewName, fName, 99); charViewName[99] = '\0';
  char *window_name = charViewName;
  char *icon_name = charViewName;
  //char tmpatom[] = "XA_WM_NORMAL_HINTS"; 
  wm_hints = XAllocWMHints();
  class_hints = XAllocClassHint();
 
  XStringListToTextProperty (&window_name, 1, &windowName);
  XStringListToTextProperty (&icon_name, 1, &iconName);
 
  wm_hints -> initial_state = NormalState;
  wm_hints -> input = True;
  wm_hints -> icon_pixmap = icon_pixmap;
  wm_hints -> flags = StateHint | IconPixmapHint | InputHint;
 
  class_hints -> res_name  = NewString("G4OpenGL");
  class_hints -> res_class = NewString("G4OpenGL");
 
   win = XCreateWindow (dpy, XRootWindow (dpy, vi -> screen), x_origin, 
                        y_origin, getWinWidth(), getWinHeight(), 0, vi -> depth,
                        InputOutput, vi -> visual,  
                        CWBorderPixel | CWColormap | 
                        CWEventMask | CWBackingStore,
                        &swa);
  
   XSetWMProperties (dpy, win, &windowName, &iconName, 0, 0, 
                     size_hints, wm_hints, class_hints);
  
// request X to Draw window on screen.
  XMapWindow (dpy, win);
 
// Wait for window to appear (wait for an "expose" event).
  XIfEvent (dpy, &event, G4OpenGLXViewerWaitForNotify, (char*) win);
 
// connect the context to a window
  Bool success = glXMakeCurrent (dpy, win, cxMaster);
  if (!success) {
    fViewId = -1;  // This flags an error.
    G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer failed to attach a GLX context."
     << G4endl;
    GLint error = GL_NO_ERROR;
    while ((error = glGetError()) != GL_NO_ERROR) {
      switch (error) {
      case GL_INVALID_ENUM :
    G4cout << "GL Error: GL_INVALID_ENUM" << G4endl;break;
      case GL_INVALID_VALUE :
    G4cout << "GL Error: GL_INVALID_VALUE" << G4endl;break;
      case GL_INVALID_OPERATION :
    G4cout << "GL Error: GL_INVALID_OPERATION" << G4endl;break;
      case GL_OUT_OF_MEMORY :
    G4cout << "GL Error: GL_OUT_OF_MEMORY" << G4endl;break;
      case GL_STACK_UNDERFLOW :
    G4cout << "GL Error: GL_STACK_UNDERFLOW" << G4endl;break;
      case GL_STACK_OVERFLOW :
    G4cout << "GL Error: GL_STACK_OVERFLOW" << G4endl;break;
      default :
    G4cout << "GL Error: " << error << G4endl;break;
      }
    }
    return;
  }
}

Referenced by G4OpenGLImmediateXViewer::Initialise(), and G4OpenGLStoredXViewer::Initialise().

DrawText()

void G4OpenGLXViewer::DrawText ( const G4Text & g4text )

virtual

Reimplemented from G4OpenGLViewer.

Definition at line 385 of file G4OpenGLXViewer.cc.

{
  if (isGl2psWriting()) {
 
    G4OpenGLViewer::DrawText(g4text);
 
  } else {
 
    G4VSceneHandler::MarkerSizeType sizeType;
    G4double size = fSceneHandler.GetMarkerSize(g4text,sizeType);
 
    const G4OpenGLFontBaseStore::FontInfo& fontInfo =
      G4OpenGLFontBaseStore::GetFontInfo(this,(int)size);
    if (fontInfo.fFontBase < 0) {
      static G4int callCount = 0;
      ++callCount;
      //if (callCount <= 10 || callCount%100 == 0) {
      if (callCount <= 1) {
        G4cout <<
      "G4OpenGLXViewer::DrawText: No fonts available for \""
           << fName <<
          "\"\n  Called with "
               << g4text
               << G4endl;
      }
      return;
    }
 
    const G4Colour& c = fSceneHandler.GetTextColour(g4text);
    glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha());
 
    G4Point3D position = g4text.GetPosition();
 
    G4String textString = g4text.GetText();
    const char* textCString = textString.c_str();
  
    // Set position for raster-style drawers (X, Xm)
    glRasterPos3d(position.x(),position.y(),position.z());
 
    glPushAttrib(GL_LIST_BIT);
 
    // Calculate move for centre and right adjustment
    G4double span = textString.size() * fontInfo.fWidth;
    G4double xmove = 0., ymove = 0.;
    switch (g4text.GetLayout()) {
    case G4Text::left: break;
    case G4Text::centre: xmove -= span / 2.; break;
    case G4Text::right: xmove -= span;
    }
 
    //Add offsets
    xmove += g4text.GetXOffset();
    ymove += g4text.GetYOffset();
 
    // Do move
    glBitmap(0,0,0,0,xmove,ymove,0);
 
    // Write characters
    glListBase(fontInfo.fFontBase);
    glCallLists((G4int)strlen(textCString),GL_UNSIGNED_BYTE,(GLubyte*)textCString);
    glPopAttrib();
  }
}

GetXConnection()

void G4OpenGLXViewer::GetXConnection ( )

protected

Definition at line 142 of file G4OpenGLXViewer.cc.

                                      {
// get a connection.
  dpy = XOpenDisplay (0);  // Uses DISPLAY environment variable.
  if (!dpy) {
    fViewId = -1;  // This flags an error.
    G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer couldn't open display." << G4endl;
    return;
  }
 
// make sure OpenGL is supported and installed properly.
  if (!glXQueryExtension (dpy, &errorBase, &eventBase)) {
    fViewId = -1;  // This flags an error.
    G4cerr << "G4OpenGLXViewer::G4OpenGLXViewer X Server has no GLX extension." 
     << G4endl;
    return;
  }
 
}

Referenced by G4OpenGLXViewer().

SetView()

void G4OpenGLXViewer::SetView ( )

virtual

Reimplemented from G4OpenGLViewer.

Definition at line 91 of file G4OpenGLXViewer.cc.

                               {
  if (G4Threading::IsMasterThread()) {
    glXMakeCurrent (dpy, win, cxMaster);
  } else {
    glXMakeCurrent (dpy, win, cxVisSubThread);
  }
  G4OpenGLViewer::SetView ();
}

Referenced by G4OpenGLXmViewer::antialias_callback(), G4OpenGLXmViewer::aux_edge_callback(), G4OpenGLXmViewer::background_color_callback(), G4OpenGLXmViewer::dolly_callback(), G4OpenGLXmViewer::drawing_style_callback(), G4OpenGLXmViewer::haloing_callback(), G4OpenGLXmViewer::left_right_pan_callback(), G4OpenGLXmViewer::projection_callback(), G4OpenGLXmViewer::reset_callback(), G4OpenGLXmViewer::rotate_in_phi(), G4OpenGLXmViewer::rotate_in_theta(), G4OpenGLXmViewer::transparency_callback(), G4OpenGLXmViewer::up_down_pan_callback(), G4OpenGLXmViewer::wobble_timer_callback(), and G4OpenGLXmViewer::zoom_callback().

ShowView()

void G4OpenGLXViewer::ShowView ( void )

virtual

Reimplemented from G4VViewer.

Definition at line 100 of file G4OpenGLXViewer.cc.

                                {
//  glXWaitGL (); //Wait for effects of all previous OpenGL commands to
                //be propagated before progressing.
// JA: Commented out July 2021 - slows rendering down in some cases and I
// don't see any adverse effects.
 
  glFlush ();
 
  if (fVP.IsPicking()) {
    G4cout <<
      "Window activated for picking (left-mouse), exit (middle-mouse)."
       << G4endl;
    while (true) {
      if (XPending(dpy)) {
    XNextEvent(dpy, &event);
    if (event.type == ButtonPress && event.xbutton.button == 1) {
      G4cout << Pick(event.xbutton.x, event.xbutton.y) << G4endl;
    }
    else if (event.type == ButtonPress && event.xbutton.button == 2) break;
      }
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
  }
}

SwitchToMasterThread()

void G4OpenGLXViewer::SwitchToMasterThread ( )

virtual

Reimplemented from G4VViewer.

Definition at line 133 of file G4OpenGLXViewer.cc.

{
#ifdef G4MULTITHREADED
  glXMakeCurrent (dpy, win, cxMaster);
  // and destroy sub-thread context
  glXDestroyContext (dpy, cxVisSubThread);
#endif
}

SwitchToVisSubThread()

void G4OpenGLXViewer::SwitchToVisSubThread ( )

virtual

Reimplemented from G4VViewer.

Definition at line 125 of file G4OpenGLXViewer.cc.

{
#ifdef G4MULTITHREADED
  cxVisSubThread = glXCreateContext (dpy, vi, cxMaster, true);
  glXMakeCurrent (dpy, win, cxVisSubThread);
#endif
}

Friends And Related Symbol Documentation

G4OpenGLXmViewer

friend class G4OpenGLXmViewer

friend

Definition at line 50 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXmViewer.

G4OpenGLXViewerMessenger

friend class G4OpenGLXViewerMessenger

friend

Definition at line 49 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewerMessenger.

Member Data Documentation

attributeList

G4int* G4OpenGLXViewer::attributeList

protected

Definition at line 85 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer().

charViewName

char G4OpenGLXViewer::charViewName[100]

protected

Definition at line 98 of file G4OpenGLXViewer.hh.

Referenced by CreateMainWindow().

class_hints

XClassHint* G4OpenGLXViewer::class_hints

protected

Definition at line 92 of file G4OpenGLXViewer.hh.

Referenced by CreateMainWindow().

cmap

Colormap G4OpenGLXViewer::cmap

protected

Definition at line 79 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXmViewer::Add_four_arrow_buttons(), G4OpenGLXmViewer::Add_radio_box(), G4OpenGLXmViewer::Add_set_field(), G4OpenGLXmViewer::Add_slider_box(), CreateGLXContext(), G4OpenGLXmViewer::CreateMainWindow(), CreateMainWindow(), and G4OpenGLXViewer().

cxMaster

GLXContext G4OpenGLXViewer::cxMaster

protected

Definition at line 82 of file G4OpenGLXViewer.hh.

Referenced by CreateGLXContext(), G4OpenGLXmViewer::CreateMainWindow(), CreateMainWindow(), SetView(), SwitchToMasterThread(), SwitchToVisSubThread(), and ~G4OpenGLXViewer().

cxVisSubThread

GLXContext G4OpenGLXViewer::cxVisSubThread

protected

Definition at line 83 of file G4OpenGLXViewer.hh.

Referenced by SetView(), SwitchToMasterThread(), and SwitchToVisSubThread().

dblBuf_RGBA

int G4OpenGLXViewer::dblBuf_RGBA

staticprotected

Initial value:

=
{ GLX_RGBA,
  GLX_RED_SIZE, 1,
  GLX_GREEN_SIZE, 1,
  GLX_BLUE_SIZE, 1,
  GLX_DOUBLEBUFFER,
  GLX_DEPTH_SIZE, 1,
  GLX_STENCIL_SIZE, 1,
  None }

Definition at line 66 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer().

dpy

Display* G4OpenGLXViewer::dpy

protected

Definition at line 73 of file G4OpenGLXViewer.hh.

Referenced by CreateFontLists(), CreateGLXContext(), G4OpenGLXmViewer::CreateMainWindow(), CreateMainWindow(), G4OpenGLStoredXmViewer::FinishView(), G4OpenGLStoredXViewer::FinishView(), G4OpenGLXViewer(), GetXConnection(), G4OpenGLXmViewer::GetXmConnection(), SetView(), ShowView(), SwitchToMasterThread(), SwitchToVisSubThread(), and ~G4OpenGLXViewer().

errorBase

G4int G4OpenGLXViewer::errorBase

protected

Definition at line 86 of file G4OpenGLXViewer.hh.

Referenced by GetXConnection(), and G4OpenGLXmViewer::GetXmConnection().

event

XEvent G4OpenGLXViewer::event

protected

Definition at line 84 of file G4OpenGLXViewer.hh.

Referenced by CreateMainWindow(), and ShowView().

eventBase

G4int G4OpenGLXViewer::eventBase

protected

Definition at line 87 of file G4OpenGLXViewer.hh.

Referenced by GetXConnection(), and G4OpenGLXmViewer::GetXmConnection().

icon_pixmap

Pixmap G4OpenGLXViewer::icon_pixmap

protected

Definition at line 93 of file G4OpenGLXViewer.hh.

Referenced by CreateMainWindow().

iconName

XTextProperty G4OpenGLXViewer::iconName

protected

Definition at line 97 of file G4OpenGLXViewer.hh.

Referenced by CreateMainWindow(), and G4OpenGLXViewer().

major

G4int G4OpenGLXViewer::major

protected

Definition at line 88 of file G4OpenGLXViewer.hh.

minor

G4int G4OpenGLXViewer::minor

protected

Definition at line 89 of file G4OpenGLXViewer.hh.

norm_hints

XSizeHints* G4OpenGLXViewer::norm_hints

protected

Definition at line 90 of file G4OpenGLXViewer.hh.

size_hints

XSizeHints* G4OpenGLXViewer::size_hints

protected

Definition at line 94 of file G4OpenGLXViewer.hh.

Referenced by CreateMainWindow().

snglBuf_RGBA

int G4OpenGLXViewer::snglBuf_RGBA

staticprotected

Initial value:

=
{ GLX_RGBA,
  GLX_RED_SIZE, 1,
  GLX_GREEN_SIZE, 1, 
  GLX_BLUE_SIZE, 1,
  GLX_DEPTH_SIZE, 1,
  GLX_STENCIL_SIZE, 1,
  None }

Definition at line 57 of file G4OpenGLXViewer.hh.

         :
  void GetXConnection ();
  void CreateGLXContext (XVisualInfo* vi);
  virtual void CreateMainWindow ();

Referenced by G4OpenGLXViewer().

swa

XSetWindowAttributes G4OpenGLXViewer::swa

protected

Definition at line 80 of file G4OpenGLXViewer.hh.

Referenced by CreateMainWindow().

vi

XVisualInfo * G4OpenGLXViewer::vi

protected

Definition at line 78 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXmViewer::Add_four_arrow_buttons(), G4OpenGLXmViewer::Add_radio_box(), G4OpenGLXmViewer::Add_set_field(), G4OpenGLXmViewer::Add_slider_box(), CreateGLXContext(), G4OpenGLXmViewer::CreateMainWindow(), CreateMainWindow(), G4OpenGLXViewer(), and SwitchToVisSubThread().

vi_double_buffer

XVisualInfo * G4OpenGLXViewer::vi_double_buffer = 0

staticprotected

Definition at line 75 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer().

vi_immediate

XVisualInfo* G4OpenGLXViewer::vi_immediate

protected

Definition at line 76 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLImmediateXmViewer::G4OpenGLImmediateXmViewer(), G4OpenGLImmediateXViewer::G4OpenGLImmediateXViewer(), G4OpenGLXViewer(), G4OpenGLImmediateXmViewer::Initialise(), and G4OpenGLImmediateXViewer::Initialise().

vi_single_buffer

XVisualInfo * G4OpenGLXViewer::vi_single_buffer = 0

staticprotected

Definition at line 74 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXViewer().

vi_stored

XVisualInfo * G4OpenGLXViewer::vi_stored

protected

Definition at line 77 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLStoredXmViewer::G4OpenGLStoredXmViewer(), G4OpenGLStoredXViewer::G4OpenGLStoredXViewer(), G4OpenGLXViewer(), G4OpenGLStoredXmViewer::Initialise(), and G4OpenGLStoredXViewer::Initialise().

win

GLXDrawable G4OpenGLXViewer::win

protected

Definition at line 81 of file G4OpenGLXViewer.hh.

Referenced by G4OpenGLXmViewer::CreateMainWindow(), CreateMainWindow(), G4OpenGLStoredXmViewer::FinishView(), G4OpenGLStoredXViewer::FinishView(), SetView(), SwitchToMasterThread(), SwitchToVisSubThread(), G4OpenGLXmViewer::~G4OpenGLXmViewer(), and ~G4OpenGLXViewer().

windowName

XTextProperty G4OpenGLXViewer::windowName

protected

Definition at line 96 of file G4OpenGLXViewer.hh.

Referenced by CreateMainWindow(), and G4OpenGLXViewer().

wm_hints

XWMHints* G4OpenGLXViewer::wm_hints

protected

Definition at line 91 of file G4OpenGLXViewer.hh.

Referenced by CreateMainWindow().

Xatom

Atom G4OpenGLXViewer::Xatom

protected

Definition at line 95 of file G4OpenGLXViewer.hh.

xwa

XWindowAttributes G4OpenGLXViewer::xwa

protected

Definition at line 72 of file G4OpenGLXViewer.hh.

Referenced by CreateGLXContext(), and G4OpenGLXViewer().

---

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

• G4OpenGLXViewer.hh
• G4OpenGLXViewer.cc