G4OpenGLViewer Class Reference

#include <G4OpenGLViewer.hh>

Inheritance diagram for G4OpenGLViewer:

Public Member Functions
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	ResetView ()
virtual void	SetView ()=0
virtual void	ClearView ()=0
virtual void	DrawView ()=0
void	RefreshView ()
virtual void	ShowView ()
virtual void	FinishView ()
std::vector< G4ThreeVector >	ComputeFlyThrough (G4Vector3D *)
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
	G4OpenGLViewer (G4OpenGLSceneHandler &scene)
virtual	~G4OpenGLViewer ()
void	SetView ()
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)
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
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.
G4bool	fNeedKernelVisit

Friends
class	G4OpenGLSceneHandler
class	G4OpenGLImmediateSceneHandler
class	G4OpenGLStoredSceneHandler
class	G4OpenGLFileSceneHandler
class	G4OpenGLViewerMessenger

Detailed Description

Definition at line 98 of file G4OpenGLViewer.hh.

Constructor & Destructor Documentation

G4OpenGLViewer()

G4OpenGLViewer::G4OpenGLViewer ( G4OpenGLSceneHandler &  scene )

protected

Definition at line 65 of file G4OpenGLViewer.cc.

                                                          :
G4VViewer (scene, -1),
#ifdef G4OPENGL_VERSION_2
fVboDrawer(NULL),
#endif
fPrintColour (true),
fVectoredPs (true),
fOpenGLSceneHandler(scene),
background (G4Colour(0.,0.,0.)),
transparency_enabled (true),
antialiasing_enabled (false),
haloing_enabled (false),
fRot_sens(1.),
fPan_sens(0.01),
fWinSize_x(0),
fWinSize_y(0),
fDefaultExportImageFormat("pdf"),
fExportImageFormat("pdf"),
fExportFilenameIndex(0),
fPrintSizeX(-1),
fPrintSizeY(-1),
fPointSize (0),
fDefaultExportFilename("G4OpenGL"),
fSizeHasChanged(0),
fGl2psDefaultLineWith(1),
fGl2psDefaultPointSize(2),
fGlViewInitialized(false),
fIsGettingPickInfos(false)
#ifdef G4OPENGL_VERSION_2
,fShaderProgram(0)
,fVertexPositionAttribute(0)
,fVertexNormalAttribute(0)
,fpMatrixUniform(0)
,fcMatrixUniform(0)
,fmvMatrixUniform(0)
,fnMatrixUniform(0)
#endif
{
  // Make changes to view parameters for OpenGL...
  fVP.SetAutoRefresh(true);
  fDefaultVP.SetAutoRefresh(true);
  fGL2PSAction = new G4gl2ps();
  tools_gl2ps_gl_funcs_t _funcs = {
    (tools_glIsEnabled_func)glIsEnabled,
    (tools_glBegin_func)glBegin,
    (tools_glEnd_func)glEnd,
    (tools_glGetFloatv_func)glGetFloatv,
    (tools_glVertex3f_func)glVertex3f,
    (tools_glGetBooleanv_func)glGetBooleanv,
    (tools_glGetIntegerv_func)glGetIntegerv,
    (tools_glRenderMode_func)glRenderMode,
    (tools_glFeedbackBuffer_func)glFeedbackBuffer,
    (tools_glPassThrough_func)glPassThrough
  };
  fGL2PSAction->setOpenGLFunctions(&_funcs);
  
  // add supported export image format
  addExportImageFormat("eps");
  addExportImageFormat("ps");
  addExportImageFormat("pdf");
  addExportImageFormat("svg");
 
  // Change the default name
  fExportFilename += fDefaultExportFilename + "_" + GetShortName().data();
  
  //  glClearColor (0.0, 0.0, 0.0, 0.0);
  //  glClearDepth (1.0);
  //  glDisable (GL_BLEND);
  //  glDisable (GL_LINE_SMOOTH);
  //  glDisable (GL_POLYGON_SMOOTH);
 
}

~G4OpenGLViewer()

G4OpenGLViewer::~G4OpenGLViewer ( )

protectedvirtual

Definition at line 138 of file G4OpenGLViewer.cc.

{
  delete fGL2PSAction;
}

Member Function Documentation

addExportImageFormat()

void G4OpenGLViewer::addExportImageFormat ( std::string  format )

protected

Definition at line 1312 of file G4OpenGLViewer.cc.

                                                          {
  fExportImageFormatVector.push_back(format);
}

Referenced by G4OpenGLQtViewer::G4OpenGLQtViewer(), and G4OpenGLViewer().

ChangeLineWidth()

void G4OpenGLViewer::ChangeLineWidth ( G4double  width )

protected

Change LineSize on gl2ps if needed

Definition at line 825 of file G4OpenGLViewer.cc.

                                                   {
 
  if (isGl2psWriting()) {
    fGL2PSAction->setLineWidth(int(width));
  } else {
    glLineWidth (width);
  }
}

Referenced by G4OpenGLSceneHandler::AddPrimitive(), HaloingFirstPass(), and HaloingSecondPass().

ChangePointSize()

void G4OpenGLViewer::ChangePointSize ( G4double  size )

protected

Change PointSize on gl2ps if needed

Definition at line 813 of file G4OpenGLViewer.cc.

                                                  {
 
  if (isGl2psWriting()) {
    fGL2PSAction->setPointSize(int(size));
  } else {
    glPointSize (size);
  }
}

Referenced by G4OpenGLSceneHandler::AddPrimitive().

ClearView()

void G4OpenGLViewer::ClearView ( void  )

virtual

Implements G4VViewer.

Definition at line 219 of file G4OpenGLViewer.cc.

                                {
  ClearViewWithoutFlush();
 
  if(!isFramebufferReady()) {
    return;
  }
 
  glFlush();
}

Referenced by G4OpenGLXmViewer::antialias_callback(), G4OpenGLXmViewer::aux_edge_callback(), G4OpenGLXmViewer::background_color_callback(), G4OpenGLXmViewer::dolly_callback(), G4OpenGLXmViewer::drawing_style_callback(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), G4OpenGLXmViewer::haloing_callback(), G4OpenGLImmediateWin32Viewer::Initialise(), G4OpenGLStoredWin32Viewer::Initialise(), InitializeGLView(), G4OpenGLXmViewer::left_right_pan_callback(), G4OpenGLImmediateQtViewer::paintGL(), G4OpenGLStoredQtViewer::paintGL(), 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().

ClearViewWithoutFlush()

void G4OpenGLViewer::ClearViewWithoutFlush

(

)

Definition at line 230 of file G4OpenGLViewer.cc.

                                            {
  // Ready for clear ?
  // See : http://lists.apple.com/archives/mac-opengl/2012/Jul/msg00038.html
  if(!isFramebufferReady()) {
    return;
  }
  
  glClearColor (background.GetRed(),
                background.GetGreen(),
                background.GetBlue(),
                1.);
  glClearDepth (1.0);
  //Below line does not compile with Mesa includes.
  //glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glClear (GL_COLOR_BUFFER_BIT);
  glClear (GL_DEPTH_BUFFER_BIT);
  glClear (GL_STENCIL_BUFFER_BIT);
}

Referenced by ClearView().

CreateFontLists()

virtual void G4OpenGLViewer::CreateFontLists ( )

inlineprotectedvirtual

Reimplemented in G4OpenGLXViewer.

Definition at line 148 of file G4OpenGLViewer.hh.

{}

Referenced by G4OpenGLImmediateWin32Viewer::Initialise(), G4OpenGLImmediateXmViewer::Initialise(), G4OpenGLStoredWin32Viewer::Initialise(), and G4OpenGLStoredXmViewer::Initialise().

DrawText()

void G4OpenGLViewer::DrawText ( const G4Text &  g4text )

protectedvirtual

Reimplemented in G4OpenGLQtViewer, and G4OpenGLXViewer.

Definition at line 773 of file G4OpenGLViewer.cc.

{
  // gl2ps or GL window ?
  if (isGl2psWriting()) {
 
    G4VSceneHandler::MarkerSizeType sizeType;
    G4double size = fSceneHandler.GetMarkerSize(g4text,sizeType);
    G4Point3D position = g4text.GetPosition();
 
    G4String textString = g4text.GetText();
    
    glRasterPos3d(position.x(),position.y(),position.z());
    GLint align = GL2PS_TEXT_B;
 
    switch (g4text.GetLayout()) {
    case G4Text::left: align = GL2PS_TEXT_BL; break;
    case G4Text::centre: align = GL2PS_TEXT_B; break;
    case G4Text::right: align = GL2PS_TEXT_BR;
    }
    
    fGL2PSAction->addTextOpt(textString.c_str(),"Times-Roman",GLshort(size),align,0);
 
  } else {
 
    static G4int callCount = 0;
    ++callCount;
    //if (callCount <= 10 || callCount%100 == 0) {
    if (callCount <= 1) {
      G4cout <<
    "G4OpenGLViewer::DrawText: Not implemented for \""
         << fName <<
    "\"\n  Called with "
         << g4text
         << G4endl;
    }
  }
}

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLQtViewer::DrawText(), and G4OpenGLXViewer::DrawText().

exportImage()

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

virtual

Export image with the given name with width and height Several cases : If name is "", filename will have the default value If name is "toto.png", set the name to "toto" and the format to "png". No incremented suffix is added. If name is "toto", set the name to "toto" and the format to default (or current format if specify). Will also add an incremented suffix at the end of the file

Reimplemented in G4OpenGLQtViewer.

Definition at line 842 of file G4OpenGLViewer.cc.

                                                                      {
 
  if (! setExportFilename(name)) {
    return false;
  }
 
  if ((width != -1) && (height != -1)) {
    setExportSize(width, height);
  }
 
  if (fExportImageFormat == "eps") {
    fGL2PSAction->setExportImageFormat_EPS();
  } else if (fExportImageFormat == "ps") {
    fGL2PSAction->setExportImageFormat_PS();
  } else if (fExportImageFormat == "svg") {
    fGL2PSAction->setExportImageFormat_SVG();
  } else if (fExportImageFormat == "pdf") {
    fGL2PSAction->setExportImageFormat_PDF();
  } else {
    setExportImageFormat(fExportImageFormat,true); // will display a message if this format is not correct for the current viewer
    return false;
  }
 
  bool res;
 
  // Change the LC_NUMERIC value in order to have "." separtor and not ","
  // This case is only useful for French, Canadien...
  size_t len = strlen(setlocale(LC_NUMERIC,NULL));
  char* oldLocale = (char*)(malloc(len+1));
  if(oldLocale!=NULL) strncpy(oldLocale,setlocale(LC_NUMERIC,NULL),len);
  setlocale(LC_NUMERIC,"C");
 
  if (((fExportImageFormat == "eps") || (fExportImageFormat == "ps")) && (!fVectoredPs)) {
    res = printNonVectoredEPS();
  } else {
    res = printVectoredEPS();
  }
 
  // restore the local
  if (oldLocale) {
    setlocale(LC_NUMERIC,oldLocale);
    free(oldLocale);
  }
 
  if (res == false) {
    G4cerr << "Error saving file... " << getRealPrintFilename().c_str() << G4endl;
  } else {
    G4cout << "File " << getRealPrintFilename().c_str() << " size: " << getRealExportWidth() << "x" << getRealExportHeight() << " has been saved " << G4endl;
 
    // increment index if necessary
    if ( fExportFilenameIndex != -1) {
      fExportFilenameIndex++;
    }
  }
 
  return res;
}

Referenced by G4OpenGLQtViewer::exportImage(), G4OpenGLXmViewer::print_callback(), and G4OpenGLViewerMessenger::SetNewValue().

g4GlFrustum()

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

protected

Definition at line 1491 of file G4OpenGLViewer.cc.

                                                                                                                             {
  //  glFrustum (left, right, bottom, top, near, far);
  
  GLdouble deltaX = right - left;
  GLdouble deltaY = top - bottom;
  GLdouble deltaZ = zFar - zNear;
  
  GLdouble a = 2.0f * zNear / deltaX;
  GLdouble b = 2.0f * zNear / deltaY;
  GLdouble c = (right + left) / deltaX;
  GLdouble d = (top + bottom) / deltaY;
  GLdouble e = -(zFar + zNear) / (zFar - zNear);
  GLdouble f = -2.0f * zFar * zNear / deltaZ;
  
  GLdouble proj[16] = {
    a, 0, 0, 0,
    0, b, 0, 0,
    c, d, e, -1.0f,
    0, 0, f, 0
  };
  
  glMultMatrixd(proj);
  
}

Referenced by SetView().

g4GlOrtho()

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

protected

Definition at line 1469 of file G4OpenGLViewer.cc.

                                                                                                                           {
  //  glOrtho (left, right, bottom, top, near, far);
  
  GLdouble a = 2.0 / (right - left);
  GLdouble b = 2.0 / (top - bottom);
  GLdouble c = -2.0 / (zFar - zNear);
  
  GLdouble tx = - (right + left)/(right - left);
  GLdouble ty = - (top + bottom)/(top - bottom);
  GLdouble tz = - (zFar + zNear)/(zFar - zNear);
  
  GLdouble ortho[16] = {
    a, 0, 0, 0,
    0, b, 0, 0,
    0, 0, c, 0,
    tx, ty, tz, 1
  };
  glMultMatrixd(ortho);
  
}

Referenced by G4OpenGLImmediateSceneHandler::BeginPrimitives2D(), G4OpenGLStoredViewer::DrawDisplayLists(), and SetView().

g4GluLookAt()

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

protected

Definition at line 1389 of file G4OpenGLViewer.cc.

{
    GLdouble mat[16];
    GLdouble x[3], y[3], z[3];
    GLdouble mag;
  
    /* Make rotation matrix */
  
    /* Z vector */
    z[0] = eyex - centerx;
    z[1] = eyey - centery;
    z[2] = eyez - centerz;
    mag = std::sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
    if (mag) {          /* mpichler, 19950515 */
        z[0] /= mag;
        z[1] /= mag;
        z[2] /= mag;
    }
  
    /* Y vector */
    y[0] = upx;
    y[1] = upy;
    y[2] = upz;
  
    /* X vector = Y cross Z */
    x[0] = y[1] * z[2] - y[2] * z[1];
    x[1] = -y[0] * z[2] + y[2] * z[0];
    x[2] = y[0] * z[1] - y[1] * z[0];
  
    /* Recompute Y = Z cross X */
    y[0] = z[1] * x[2] - z[2] * x[1];
    y[1] = -z[0] * x[2] + z[2] * x[0];
    y[2] = z[0] * x[1] - z[1] * x[0];
  
    /* mpichler, 19950515 */
    /* cross product gives area of parallelogram, which is < 1.0 for
     * non-perpendicular unit-length vectors; so normalize x, y here
     */
  
    mag = std::sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
    if (mag) {
        x[0] /= mag;
        x[1] /= mag;
        x[2] /= mag;
    }
  
    mag = std::sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
    if (mag) {
        y[0] /= mag;
        y[1] /= mag;
        y[2] /= mag;
    }
  
#define M(row,col)  mat[col*4+row]
    M(0, 0) = x[0];
    M(0, 1) = x[1];
    M(0, 2) = x[2];
    M(0, 3) = 0.0;
    M(1, 0) = y[0];
    M(1, 1) = y[1];
    M(1, 2) = y[2];
    M(1, 3) = 0.0;
    M(2, 0) = z[0];
    M(2, 1) = z[1];
    M(2, 2) = z[2];
    M(2, 3) = 0.0;
    M(3, 0) = 0.0;
    M(3, 1) = 0.0;
    M(3, 2) = 0.0;
    M(3, 3) = 1.0;
#undef M
    glMultMatrixd(mat);
  
    /* Translate Eye to Origin */
    glTranslated(-eyex, -eyey, -eyez);
}

Referenced by SetView().

g4GluPickMatrix()

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

protected

Definition at line 1347 of file G4OpenGLViewer.cc.

  {
    GLdouble mat[16];
    GLdouble sx, sy;
    GLdouble tx, ty;
    
    sx = viewport[2] / width;
    sy = viewport[3] / height;
    tx = (viewport[2] + 2.0 * (viewport[0] - x)) / width;
    ty = (viewport[3] + 2.0 * (viewport[1] - y)) / height;
    
#define M(row, col) mat[col*4+row]
    M(0, 0) = sx;
    M(0, 1) = 0.0;
    M(0, 2) = 0.0;
    M(0, 3) = tx;
    M(1, 0) = 0.0;
    M(1, 1) = sy;
    M(1, 2) = 0.0;
    M(1, 3) = ty;
    M(2, 0) = 0.0;
    M(2, 1) = 0.0;
    M(2, 2) = 1.0;
    M(2, 3) = 0.0;
    M(3, 0) = 0.0;
    M(3, 1) = 0.0;
    M(3, 2) = 0.0;
    M(3, 3) = 1.0;
#undef M
    
    glMultMatrixd(mat);
}

Referenced by GetPickDetails().

GetPickDetails()

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

protected

Definition at line 503 of file G4OpenGLViewer.cc.

{
  static std::vector < G4OpenGLViewerPickMap* > pickMapVector;
  for (auto pickMap: pickMapVector) {
    delete pickMap;
  }
  pickMapVector.clear();
  
  const G4int BUFSIZE = 512;
  GLuint selectBuffer[BUFSIZE];
  glSelectBuffer(BUFSIZE, selectBuffer);
  glRenderMode(GL_SELECT);
  glInitNames();
  glPushName(0);
  glMatrixMode(GL_PROJECTION);
  G4double currentProjectionMatrix[16];
  glGetDoublev(GL_PROJECTION_MATRIX, currentProjectionMatrix);
  glPushMatrix();
  glLoadIdentity();
  GLint viewport[4];
  glGetIntegerv(GL_VIEWPORT, viewport);
/*  G4cout
  << "viewport, x,y: "
  << viewport[0] << ',' << viewport[1] << ',' << viewport[2] << ',' << viewport[3]
  << ", " << x << ',' << y
  << G4endl;
*/
  fIsGettingPickInfos = true;
  // Define 5x5 pixel pick area
  g4GluPickMatrix(x, viewport[3] - y, 5., 5., viewport);
  glMultMatrixd(currentProjectionMatrix);
  glMatrixMode(GL_MODELVIEW);
  DrawView();
  GLint hits = glRenderMode(GL_RENDER);
  fIsGettingPickInfos = false;
  if (hits < 0) {
    G4cout << "Too many hits.  Zoom in to reduce overlaps." << G4endl;
    goto restoreMatrices;
  }
  if (hits > 0) {
    GLuint* p = selectBuffer;
    for (GLint i = 0; i < hits; ++i) {
      GLuint nnames = *p++;
      // This bit of debug code or...
      //GLuint zmin = *p++;
      //GLuint zmax = *p++;
      //G4cout << "Hit " << i << ": " << nnames << " names"
      //       << "\nzmin: " << zmin << ", zmax: " << zmax << G4endl;
      // ...just increment the pointer
      p++;
      p++;
      for (GLuint j = 0; j < nnames; ++j) {
        GLuint name = *p++;
    std::map<GLuint, G4AttHolder*>::iterator iter =
      fOpenGLSceneHandler.fPickMap.find(name);
    if (iter != fOpenGLSceneHandler.fPickMap.end()) {
      G4AttHolder* attHolder = iter->second;
      if(attHolder && attHolder->GetAttDefs().size()) {
        for (size_t iAtt = 0;
         iAtt < attHolder->GetAttDefs().size(); ++iAtt) {
              std::ostringstream oss;
          oss << G4AttCheck(attHolder->GetAttValues()[iAtt],
                                attHolder->GetAttDefs()[iAtt]);
              G4OpenGLViewerPickMap* pickMap = new G4OpenGLViewerPickMap();
//              G4cout
//              << "i,j, attHolder->GetAttDefs().size(): "
//              << i << ',' << j
//              << ", " << attHolder->GetAttDefs().size()
//              << G4endl;
//              G4cout << "G4OpenGLViewer::GetPickDetails: " << oss.str() << G4endl;
              pickMap->addAttributes(oss.str());
              pickMap->setHitNumber(i);
              pickMap->setSubHitNumber(j);
              pickMap->setPickName(name);
              pickMapVector.push_back(pickMap);
            }
          }
        }
      }
    }
  }
 
restoreMatrices:
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
 
  return pickMapVector;
}

Referenced by Pick(), and G4OpenGLQtViewer::updatePickInfosWidget().

getRealPrintFilename()

std::string G4OpenGLViewer::getRealPrintFilename ( )

protected

Definition at line 1090 of file G4OpenGLViewer.cc.

                                               {
  std::string temp = fExportFilename;
  if (fExportFilenameIndex != -1) {
    temp += std::string("_");
    std::ostringstream os;
    os << std::setw(4) << std::setfill('0') << fExportFilenameIndex;
    std::string nb_str = os.str();
    temp += nb_str;
  }
  temp += "."+fExportImageFormat;
  return temp;
}

Referenced by G4OpenGLQtViewer::exportImage(), exportImage(), G4OpenGLXmViewer::misc_callback(), and setExportFilename().

getSceneDepth()

GLdouble G4OpenGLViewer::getSceneDepth ( )

protected

Definition at line 1135 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return 0;
  }
  const G4Point3D targetPoint
    = fSceneHandler.GetScene()->GetStandardTargetPoint()
    + fVP.GetCurrentTargetPoint ();
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
  if(radius<=0.) radius = 1.;
  const G4double cameraDistance = fVP.GetCameraDistance (radius);
  const GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
  return fVP.GetFarDistance  (cameraDistance, pnear, radius)- pnear;
}

Referenced by G4OpenGLQtViewer::moveScene().

getSceneFarWidth()

GLdouble G4OpenGLViewer::getSceneFarWidth ( )

protected

Definition at line 1118 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return 0;
  }
  const G4Point3D targetPoint
    = fSceneHandler.GetScene()->GetStandardTargetPoint()
    + fVP.GetCurrentTargetPoint ();
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
  if(radius<=0.) radius = 1.;
  const G4double cameraDistance = fVP.GetCameraDistance (radius);
  const GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
  const GLdouble pfar    = fVP.GetFarDistance  (cameraDistance, pnear, radius);
  return 2 * fVP.GetFrontHalfHeight (pfar, radius);
}

getSceneNearWidth()

GLdouble G4OpenGLViewer::getSceneNearWidth ( )

protected

Definition at line 1103 of file G4OpenGLViewer.cc.

{
  if (!fSceneHandler.GetScene()) {
    return 0;
  }
  const G4Point3D targetPoint
    = fSceneHandler.GetScene()->GetStandardTargetPoint()
    + fVP.GetCurrentTargetPoint ();
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
  if(radius<=0.) radius = 1.;
  const G4double cameraDistance = fVP.GetCameraDistance (radius);
  const GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
  return 2 * fVP.GetFrontHalfHeight (pnear, radius);
}

Referenced by G4OpenGLQtViewer::G4MousePressEvent(), and G4OpenGLQtViewer::moveScene().

getWinHeight()

unsigned int G4OpenGLViewer::getWinHeight ( ) const

protected

Definition at line 1001 of file G4OpenGLViewer.cc.

                                               {
  return fWinSize_y;
}

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::DrawText(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::moveScene(), G4OpenGLImmediateQtViewer::paintGL(), and G4OpenGLStoredQtViewer::paintGL().

getWinWidth()

unsigned int G4OpenGLViewer::getWinWidth ( ) const

protected

Definition at line 997 of file G4OpenGLViewer.cc.

                                              {
  return fWinSize_x;
}

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLQtViewer::DrawText(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLQtViewer::G4MouseMoveEvent(), G4OpenGLQtViewer::G4MousePressEvent(), G4OpenGLQtViewer::moveScene(), G4OpenGLImmediateQtViewer::paintGL(), and G4OpenGLStoredQtViewer::paintGL().

HaloingFirstPass()

void G4OpenGLViewer::HaloingFirstPass ( )

protected

Definition at line 456 of file G4OpenGLViewer.cc.

                                       {
  
  //To perform haloing, first Draw all information to the depth buffer
  //alone, using a chunky line width, and then Draw all info again, to
  //the colour buffer, setting a thinner line width an the depth testing 
  //function to less than or equal, so if two lines cross, the one 
  //passing behind the other will not pass the depth test, and so not
  //get rendered either side of the infront line for a short distance.
 
  //First, disable writing to the colo(u)r buffer...
  glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
  //Now enable writing to the depth buffer...
  glDepthMask (GL_TRUE);
  glDepthFunc (GL_LESS);
  glClearDepth (1.0);
 
  //Finally, set the line width to something wide...
  ChangeLineWidth(3.0);
 
}

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

HaloingSecondPass()

void G4OpenGLViewer::HaloingSecondPass ( )

protected

Definition at line 478 of file G4OpenGLViewer.cc.

                                        {
 
  //And finally, turn the colour buffer back on with a sesible line width...
  glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  glDepthFunc (GL_LEQUAL);
  ChangeLineWidth(1.0);
 
}

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

HLRFirstPass()

void G4OpenGLViewer::HLRFirstPass ( )

protected

HLRSecondPass()

void G4OpenGLViewer::HLRSecondPass ( )

protected

HLRThirdPass()

void G4OpenGLViewer::HLRThirdPass ( )

protected

InitializeGLView()

void G4OpenGLViewer::InitializeGLView ( )

protected

Definition at line 143 of file G4OpenGLViewer.cc.

{
#ifdef G4OPENGL_VERSION_2
  if (fVboDrawer) {
    
    // First, load a simple shader
    fShaderProgram = glCreateProgram();
    Shader vertexShader = glCreateShader(GL_VERTEX_SHADER);
    const char * vSrc = fVboDrawer->getVertexShaderSrc();
    glShaderSource(vertexShader, 1, &vSrc, NULL);
    glCompileShader(vertexShader);
    glAttachShader(fShaderProgram, vertexShader);
    
    Shader fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    const char * fSrc = fVboDrawer->getFragmentShaderSrc();
    glShaderSource(fragmentShader, 1, &fSrc, NULL);
    glCompileShader(fragmentShader);
    
    glAttachShader(fShaderProgram, fragmentShader);
    glLinkProgram(fShaderProgram);
    glUseProgram(fShaderProgram);
    
    //   UniformLocation uColor = getUniformLocation(fShaderProgram, "uColor");
    //   uniform4fv(uColor, [0.0, 0.3, 0.0, 1.0]);
    
    // Extract the references to the attributes from the shader.
    
    fVertexPositionAttribute =
    glGetAttribLocation(fShaderProgram, "aVertexPosition");
    
    
    glEnableVertexAttribArray(fVertexPositionAttribute);
    
    // Extract the references the uniforms from the shader
    fpMatrixUniform  = glGetUniformLocation(fShaderProgram, "uPMatrix");
    fcMatrixUniform  = glGetUniformLocation(fShaderProgram, "uCMatrix");
    fmvMatrixUniform = glGetUniformLocation(fShaderProgram, "uMVMatrix");
    fnMatrixUniform  = glGetUniformLocation(fShaderProgram, "uNMatrix");
    ftMatrixUniform  = glGetUniformLocation(fShaderProgram, "uTMatrix");
    
    /*    glUniformMatrix4fv(fcMatrixUniform, 1, 0, identity);
     glUniformMatrix4fv(fpMatrixUniform, 1, 0, identity);
     glUniformMatrix4fv(ftMatrixUniform, 1, 0, identity);
     glUniformMatrix4fv(fmvMatrixUniform, 1, 0, identity);
     */
    // We have to set that in order to avoid calls on opengl commands before all is ready
    fGlViewInitialized = true;
  }
#endif
  
  if (fWinSize_x == 0) {
    fWinSize_x = fVP.GetWindowSizeHintX();
  }
  if (fWinSize_y == 0) {
    fWinSize_y = fVP.GetWindowSizeHintY();
  }
 
  glClearColor (0.0, 0.0, 0.0, 0.0);
  glClearDepth (1.0);
#ifndef G4OPENGL_VERSION_2
  glDisable (GL_LINE_SMOOTH);
  glDisable (GL_POLYGON_SMOOTH);
#endif
 
// clear the buffers and window?
  ClearView ();
  FinishView ();
  
  glDepthFunc (GL_LEQUAL);
  glDepthMask (GL_TRUE);
  
  glEnable (GL_BLEND);
  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  
}

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

isFramebufferReady()

G4bool G4OpenGLViewer::isFramebufferReady ( )

protected

Definition at line 745 of file G4OpenGLViewer.cc.

                                          {
  bool check = false;
#ifdef G4VIS_BUILD_OPENGLQT_DRIVER
  check = true;
#endif
#ifdef G4VIS_BUILD_OPENGLX_DRIVER
  check = false;
#endif
#ifdef G4VIS_BUILD_OPENGLXM_DRIVER
  check = false;
#endif
#ifdef G4VIS_BUILD_OPENGLWIN32_DRIVER
  check = false;
#endif
 
#if GL_ARB_framebuffer_object
  if (check) {
//    if ( glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_UNDEFINED) {
//      return false;
//    }
  }
#endif
    return true;
}

Referenced by ClearView(), ClearViewWithoutFlush(), G4OpenGLImmediateQtViewer::paintEvent(), and G4OpenGLStoredQtViewer::paintEvent().

isGl2psWriting()

bool G4OpenGLViewer::isGl2psWriting ( )

protected

Return if gl2ps is currently writing

Definition at line 735 of file G4OpenGLViewer.cc.

                                    {
 
  if (!fGL2PSAction) return false;
  if (fGL2PSAction->fileWritingEnabled()) {
    return true;
  }
  return false;
}

Referenced by ChangeLineWidth(), ChangePointSize(), G4OpenGLQtViewer::DrawText(), DrawText(), and G4OpenGLXViewer::DrawText().

Pick()

G4String G4OpenGLViewer::Pick ( GLdouble  x, GLdouble  y  )

protectedvirtual

Definition at line 487 of file G4OpenGLViewer.cc.

{
  const std::vector < G4OpenGLViewerPickMap* > & pickMap = GetPickDetails(x,y);
  G4String txt = "";
  if (pickMap.size() == 0) {
//        txt += "No hits recorded.";;
  } else {
    for (unsigned int a=0; a < pickMap.size(); a++) {
      if (pickMap[a]->getAttributes().size() > 0) {
        txt += pickMap[a]->print();
      }
    }
  }
  return txt;
}

Referenced by G4OpenGLXViewer::ShowView().

ResetView()

void G4OpenGLViewer::ResetView ( )

protectedvirtual

Reimplemented from G4VViewer.

Reimplemented in G4OpenGLXmViewer.

Definition at line 449 of file G4OpenGLViewer.cc.

                                {
  G4VViewer::ResetView();
  fRot_sens = 1;
  fPan_sens = 0.01;
}

Referenced by G4OpenGLQtViewer::ResetView(), and G4OpenGLXmViewer::ResetView().

ResizeGLView()

void G4OpenGLViewer::ResizeGLView ( )

protected

Set the viewport of the scene MAXIMUM SIZE is : GLint dims[2]; glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);

Definition at line 266 of file G4OpenGLViewer.cc.

{
  // Check size
  GLint dims[2];
  dims[0] = 0;
  dims[1] = 0;
 
  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
 
  if ((dims[0] !=0 ) && (dims[1] !=0)) {
 
    if (fWinSize_x > (unsigned)dims[0]) {
      G4cerr << "Try to resize view greater than max X viewport dimension. Desired size "<<fWinSize_x <<" is resize to "<<  dims[0] << G4endl;
      fWinSize_x = dims[0];
    }
    if (fWinSize_y > (unsigned)dims[1]) {
      G4cerr << "Try to resize view greater than max Y viewport dimension. Desired size "<<fWinSize_y <<" is resize to "<<  dims[1] << G4endl;
      fWinSize_y = dims[1];
    }
  }
    
  glViewport(0, 0, fWinSize_x,fWinSize_y);   
 
 
}

Referenced by SetView().

ResizeWindow()

void G4OpenGLViewer::ResizeWindow ( unsigned int  aWidth, unsigned int  aHeight  )

protected

Definition at line 250 of file G4OpenGLViewer.cc.

                                                                           {
  if ((fWinSize_x != aWidth) || (fWinSize_y != aHeight)) {
    fWinSize_x = aWidth;
    fWinSize_y = aHeight;
    fSizeHasChanged = true;
  } else {
    fSizeHasChanged = false;
  }
}

Referenced by G4OpenGLWin32Viewer::CreateMainWindow(), G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLXViewer::CreateMainWindow(), G4OpenGLQtViewer::CreateMainWindow(), G4OpenGLXmViewer::expose_callback(), G4OpenGLImmediateQtViewer::resizeGL(), and G4OpenGLStoredQtViewer::resizeGL().

rotateScene()

void G4OpenGLViewer::rotateScene ( G4double  dx, G4double  dy  )

protected

Definition at line 1152 of file G4OpenGLViewer.cc.

{
  if (fVP.GetRotationStyle() == G4ViewParameters::freeRotation) {
    rotateSceneInViewDirection(dx,dy);
  } else {
    if( dx != 0) {
      rotateSceneThetaPhi(dx,0);
    }
    if( dy != 0) {
      rotateSceneThetaPhi(0,dy);
    }
  }
}

Referenced by G4OpenGLXmViewer::rotate_in_phi(), G4OpenGLXmViewer::rotate_in_theta(), and G4OpenGLQtViewer::rotateQtScene().

rotateSceneToggle()

void G4OpenGLViewer::rotateSceneToggle ( G4double  dx, G4double  dy  )

protected

Definition at line 1167 of file G4OpenGLViewer.cc.

{
  if (fVP.GetRotationStyle() != G4ViewParameters::freeRotation) {
    rotateSceneInViewDirection(dx,dy);
  } else {
    if( dx != 0) {
      rotateSceneThetaPhi(dx,0);
    }
    if( dy != 0) {
      rotateSceneThetaPhi(0,dy);
    }
  }
}

Referenced by G4OpenGLQtViewer::rotateQtSceneToggle().

setExportFilename()

bool G4OpenGLViewer::setExportFilename ( G4String  name, G4bool  inc = true  )

protected

If name is "" or "!", filename and extension will have the default value. If name is "toto.png", set the name to "toto" and the format to "png". No incremented suffix is added. If name is "toto", set the name to "toto" and the format to default (or current format if specify). If name is the same as previous, do not reset incremented suffix.

Definition at line 1058 of file G4OpenGLViewer.cc.

                                                               {
  if (name == "!") {
    name = "";
  }
 
  if (inc) {
    if ((name != "") && (fExportFilename != name)) {
      fExportFilenameIndex=0;
    }
  } else {
    fExportFilenameIndex=-1;
  }
 
  if (name.size() == 0) {
    name = getRealPrintFilename().c_str();
  } else {
    // guess format by extention
    std::string extension = name.substr(name.find_last_of(".") + 1);
    // If there is a dot in the name the above might find rubbish, so...
    if (extension.size() >= 3 && extension.size() <= 4) {  // Possible extension
      if (setExportImageFormat(extension, false)) {  // Extension found
        fExportFilename = name.substr(0,name.find_last_of("."));
      } else {  // No viable extension found
        return false;
      }
    } else {  // Assume name is already the required without-extension part
        fExportFilename = name;
    }
  }
  return true;
}

Referenced by G4OpenGLQtViewer::exportImage(), exportImage(), and G4OpenGLViewerMessenger::SetNewValue().

setExportImageFormat()

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

Definition at line 1316 of file G4OpenGLViewer.cc.

                                                                      {
  bool found = false;
  std::string list;
  for (unsigned int a=0; a<fExportImageFormatVector.size(); a++) {
    list +=fExportImageFormatVector.at(a) + " ";
 
    if (fExportImageFormatVector.at(a) == format) {
      if (! quiet) {
        G4cout << " Changing export format to \"" << format << "\"" << G4endl;
      }
      if (format != fExportImageFormat) {
        fExportFilenameIndex = 0;
        fExportImageFormat = format;
      }
      return true;
    }
  }
  if (! found) {
    if (format.size() == 0) {
      G4cout << " Current formats availables are : " << list << G4endl;
    } else {
      G4cerr << " Format \"" << format << "\" is not available for the selected viewer. Current formats availables are : " << list << G4endl;
    }
  }
  return false;
}

Referenced by exportImage(), G4OpenGLImmediateQtViewer::initializeGL(), G4OpenGLStoredQtViewer::initializeGL(), setExportFilename(), and G4OpenGLViewerMessenger::SetNewValue().

setExportSize()

void G4OpenGLViewer::setExportSize ( G4int  X, G4int  Y  )

protected

Definition at line 1047 of file G4OpenGLViewer.cc.

                                                   {
  fPrintSizeX = X;
  fPrintSizeY = Y;
}

Referenced by G4OpenGLQtViewer::exportImage(), exportImage(), and G4OpenGLViewerMessenger::SetNewValue().

SetView()

void G4OpenGLViewer::SetView ( )

protectedvirtual

Implements G4VViewer.

Reimplemented in G4OpenGLWin32Viewer, and G4OpenGLXViewer.

Definition at line 293 of file G4OpenGLViewer.cc.

                              {
  // if getting pick infos, should not resize the view.
  if (fIsGettingPickInfos) return;
  
  if (!fSceneHandler.GetScene()) {
    return;
  }
  // Calculates view representation based on extent of object being
  // viewed and (initial) viewpoint.  (Note: it can change later due
  // to user interaction via visualization system's GUI.)
  
  // Lighting.
  GLfloat lightPosition [4];
  lightPosition [0] = fVP.GetActualLightpointDirection().x();
  lightPosition [1] = fVP.GetActualLightpointDirection().y();
  lightPosition [2] = fVP.GetActualLightpointDirection().z();
  lightPosition [3] = 0.;
  // Light position is "true" light direction, so must come after gluLookAt.
  GLfloat ambient [] = { 0.2f, 0.2f, 0.2f, 1.f};
  GLfloat diffuse [] = { 0.8f, 0.8f, 0.8f, 1.f};
  glEnable (GL_LIGHT0);
  glLightfv (GL_LIGHT0, GL_AMBIENT, ambient);
  glLightfv (GL_LIGHT0, GL_DIFFUSE, diffuse);
  
  G4double ratioX = 1;
  G4double ratioY = 1;
  if (fWinSize_y > fWinSize_x) {
    ratioX = ((G4double)fWinSize_y) / ((G4double)fWinSize_x);
  }
  if (fWinSize_x > fWinSize_y) {
    ratioY = ((G4double)fWinSize_x) / ((G4double)fWinSize_y);
  }
  
  // Get radius of scene, etc.
  // Note that this procedure properly takes into account zoom, dolly and pan.
  const G4Point3D targetPoint
    = fSceneHandler.GetScene()->GetStandardTargetPoint()
    + fVP.GetCurrentTargetPoint ();
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
  if(radius<=0.) radius = 1.;
  const G4double cameraDistance = fVP.GetCameraDistance (radius);
  const G4Point3D cameraPosition =
    targetPoint + cameraDistance * fVP.GetViewpointDirection().unit();
  const GLdouble pnear  = fVP.GetNearDistance (cameraDistance, radius);
  const GLdouble pfar   = fVP.GetFarDistance  (cameraDistance, pnear, radius);
  const GLdouble right  = fVP.GetFrontHalfHeight (pnear, radius) * ratioY;
  const GLdouble left   = -right;
  const GLdouble top    = fVP.GetFrontHalfHeight (pnear, radius) * ratioX;
  const GLdouble bottom = -top;
  
  // FIXME
  ResizeGLView();
  //SHOULD SetWindowsSizeHint()...
 
  glMatrixMode (GL_PROJECTION); // set up Frustum.
  glLoadIdentity();
 
  const G4Vector3D scaleFactor = fVP.GetScaleFactor();
  glScaled(scaleFactor.x(),scaleFactor.y(),scaleFactor.z());
  
  if (fVP.GetFieldHalfAngle() == 0.) {
    g4GlOrtho (left, right, bottom, top, pnear, pfar);
  }
  else {
    g4GlFrustum (left, right, bottom, top, pnear, pfar);
  }  
 
  glMatrixMode (GL_MODELVIEW); // apply further transformations to scene.
  glLoadIdentity();
  
  const G4Normal3D& upVector = fVP.GetUpVector ();  
  G4Point3D gltarget;
  if (cameraDistance > 1.e-6 * radius) {
    gltarget = targetPoint;
  }
  else {
    gltarget = targetPoint - radius * fVP.GetViewpointDirection().unit();
  }
 
  const G4Point3D& pCamera = cameraPosition;  // An alias for brevity.
 
  g4GluLookAt (pCamera.x(),  pCamera.y(),  pCamera.z(),       // Viewpoint.
             gltarget.x(), gltarget.y(), gltarget.z(),      // Target point.
             upVector.x(), upVector.y(), upVector.z());     // Up vector.
  // Light position is "true" light direction, so must come after gluLookAt.
  glLightfv (GL_LIGHT0, GL_POSITION, lightPosition);
 
  // The idea is to use back-to-back clipping planes.  This can cut an object
  // down to just a few pixels, which can make it difficult to see.  So, for
  // now, comment this out and use the generic (Boolean) method, via
  // G4VSolid* G4OpenGLSceneHandler::CreateSectionSolid ()
  // { return G4VSceneHandler::CreateSectionSolid(); }
//  if (fVP.IsSection () ) {  // pair of back to back clip planes.
//    const G4Plane3D& sp = fVP.GetSectionPlane ();
//    double sArray[4];
//    sArray[0] = sp.a();
//    sArray[1] = sp.b();
//    sArray[2] = sp.c();
//    sArray[3] = sp.d() + radius * 1.e-05;
//    glClipPlane (GL_CLIP_PLANE0, sArray);
//    glEnable (GL_CLIP_PLANE0);
//    sArray[0] = -sp.a();
//    sArray[1] = -sp.b();
//    sArray[2] = -sp.c();
//    sArray[3] = -sp.d() + radius * 1.e-05;
//    glClipPlane (GL_CLIP_PLANE1, sArray);
//    glEnable (GL_CLIP_PLANE1);
//  } else {
//    glDisable (GL_CLIP_PLANE0);
//    glDisable (GL_CLIP_PLANE1);
//  }
 
  // What we call intersection of cutaways is easy in OpenGL.  You
  // just keep cutting.  Unions are more tricky - you have to have
  // multiple passes and this is handled in
  // G4OpenGLImmediate/StoredViewer::ProcessView.
  const G4Planes& cutaways = fVP.GetCutawayPlanes();
  size_t nPlanes = cutaways.size();
  if (fVP.IsCutaway() &&
      fVP.GetCutawayMode() == G4ViewParameters::cutawayIntersection) {
    double a[4];
    a[0] = cutaways[0].a();
    a[1] = cutaways[0].b();
    a[2] = cutaways[0].c();
    a[3] = cutaways[0].d();
    glClipPlane (GL_CLIP_PLANE2, a);
    glEnable (GL_CLIP_PLANE2);
    if (nPlanes > 1) {
      a[0] = cutaways[1].a();
      a[1] = cutaways[1].b();
      a[2] = cutaways[1].c();
      a[3] = cutaways[1].d();
      glClipPlane (GL_CLIP_PLANE3, a);
      glEnable (GL_CLIP_PLANE3);
    }
    if (nPlanes > 2) {
      a[0] = cutaways[2].a();
      a[1] = cutaways[2].b();
      a[2] = cutaways[2].c();
      a[3] = cutaways[2].d();
      glClipPlane (GL_CLIP_PLANE4, a);
      glEnable (GL_CLIP_PLANE4);
    }
  } else {
    glDisable (GL_CLIP_PLANE2);
    glDisable (GL_CLIP_PLANE3);
    glDisable (GL_CLIP_PLANE4);
  }
 
  // Background.
  background = fVP.GetBackgroundColour ();
 
}

Referenced by G4OpenGLImmediateQtViewer::paintGL(), G4OpenGLStoredQtViewer::paintGL(), G4OpenGLWin32Viewer::SetView(), and G4OpenGLXViewer::SetView().

sizeHasChanged()

G4bool G4OpenGLViewer::sizeHasChanged ( )

protected

Definition at line 1005 of file G4OpenGLViewer.cc.

                                      {
  return fSizeHasChanged;
}

Referenced by G4OpenGLImmediateQtViewer::resizeGL(), and G4OpenGLStoredQtViewer::resizeGL().

Friends And Related Function Documentation

G4OpenGLFileSceneHandler

friend class G4OpenGLFileSceneHandler

friend

Definition at line 103 of file G4OpenGLViewer.hh.

G4OpenGLImmediateSceneHandler

friend class G4OpenGLImmediateSceneHandler

friend

Definition at line 101 of file G4OpenGLViewer.hh.

G4OpenGLSceneHandler

friend class G4OpenGLSceneHandler

friend

Definition at line 100 of file G4OpenGLViewer.hh.

G4OpenGLStoredSceneHandler

friend class G4OpenGLStoredSceneHandler

friend

Definition at line 102 of file G4OpenGLViewer.hh.

G4OpenGLViewerMessenger

friend class G4OpenGLViewerMessenger

friend

Definition at line 104 of file G4OpenGLViewer.hh.

Member Data Documentation

antialiasing_enabled

G4bool G4OpenGLViewer::antialiasing_enabled

protected

Definition at line 201 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::antialias_callback(), and G4OpenGLXmViewer::CreateMainWindow().

background

G4Colour G4OpenGLViewer::background

protected

Definition at line 198 of file G4OpenGLViewer.hh.

Referenced by ClearViewWithoutFlush(), G4OpenGLXmViewer::CreateMainWindow(), and SetView().

fDefaultExportImageFormat

std::string G4OpenGLViewer::fDefaultExportImageFormat

protected

Definition at line 210 of file G4OpenGLViewer.hh.

fExportFilenameIndex

int G4OpenGLViewer::fExportFilenameIndex

protected

Definition at line 212 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::exportImage(), exportImage(), getRealPrintFilename(), setExportFilename(), and setExportImageFormat().

fExportImageFormat

std::string G4OpenGLViewer::fExportImageFormat

protected

Definition at line 211 of file G4OpenGLViewer.hh.

Referenced by exportImage(), getRealPrintFilename(), and setExportImageFormat().

fExportImageFormatVector

std::vector< std::string > G4OpenGLViewer::fExportImageFormatVector

protected

Definition at line 209 of file G4OpenGLViewer.hh.

Referenced by addExportImageFormat(), and setExportImageFormat().

fGL2PSAction

G4gl2ps* G4OpenGLViewer::fGL2PSAction

protected

Definition at line 203 of file G4OpenGLViewer.hh.

Referenced by ChangeLineWidth(), ChangePointSize(), DrawText(), exportImage(), G4OpenGLViewer(), isGl2psWriting(), and ~G4OpenGLViewer().

fOpenGLSceneHandler

G4OpenGLSceneHandler& G4OpenGLViewer::fOpenGLSceneHandler

protected

Definition at line 197 of file G4OpenGLViewer.hh.

Referenced by GetPickDetails().

fPan_sens

G4double G4OpenGLViewer::fPan_sens

protected

Definition at line 206 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::actions_callback(), G4OpenGLXmViewer::left_right_pan_callback(), G4OpenGLQtViewer::moveScene(), ResetView(), G4OpenGLXmViewer::ResetView(), G4OpenGLXmViewer::set_pan_sens_callback(), and G4OpenGLXmViewer::up_down_pan_callback().

fPrintColour

G4bool G4OpenGLViewer::fPrintColour

protected

Definition at line 194 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::misc_callback(), G4OpenGLXmViewer::set_print_colour_callback(), and G4OpenGLXmViewer::set_print_style_callback().

fPrintSizeX

G4int G4OpenGLViewer::fPrintSizeX

protected

Definition at line 213 of file G4OpenGLViewer.hh.

Referenced by setExportSize().

fPrintSizeY

G4int G4OpenGLViewer::fPrintSizeY

protected

Definition at line 214 of file G4OpenGLViewer.hh.

Referenced by setExportSize().

fRot_sens

G4double G4OpenGLViewer::fRot_sens

protected

Definition at line 205 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::actions_callback(), G4OpenGLQtViewer::G4keyPressEvent(), ResetView(), and G4OpenGLXmViewer::set_rot_sens_callback().

fVectoredPs

G4bool G4OpenGLViewer::fVectoredPs

protected

Definition at line 195 of file G4OpenGLViewer.hh.

Referenced by exportImage(), G4OpenGLXmViewer::misc_callback(), G4OpenGLXmViewer::set_print_style_callback(), and G4OpenGLViewerMessenger::SetNewValue().

fWinSize_x

unsigned int G4OpenGLViewer::fWinSize_x

protected

Definition at line 207 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::CreateMainWindow(), getWinWidth(), InitializeGLView(), ResizeGLView(), ResizeWindow(), and SetView().

fWinSize_y

unsigned int G4OpenGLViewer::fWinSize_y

protected

Definition at line 208 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLQtViewer::CreateMainWindow(), getWinHeight(), InitializeGLView(), ResizeGLView(), ResizeWindow(), and SetView().

haloing_enabled

G4bool G4OpenGLViewer::haloing_enabled

protected

Definition at line 202 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLImmediateWin32Viewer::DrawView(), G4OpenGLImmediateXmViewer::DrawView(), G4OpenGLImmediateXViewer::DrawView(), G4OpenGLStoredWin32Viewer::DrawView(), G4OpenGLStoredXmViewer::DrawView(), G4OpenGLStoredXViewer::DrawView(), and G4OpenGLXmViewer::haloing_callback().

transparency_enabled

G4bool G4OpenGLViewer::transparency_enabled

protected

Definition at line 200 of file G4OpenGLViewer.hh.

Referenced by G4OpenGLXmViewer::CreateMainWindow(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLViewerMessenger::SetNewValue(), and G4OpenGLXmViewer::transparency_callback().

---

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

• G4OpenGLViewer.hh
• G4OpenGLViewer.cc