Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/OpenGL/src/G4OpenGLViewer.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/OpenGL/src/G4OpenGLViewer.cc (Version 11.3.0) and /visualization/OpenGL/src/G4OpenGLViewer.cc (Version 9.4.p3)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 //                                                 26 //
                                                   >>  27 // $Id: G4OpenGLViewer.cc,v 1.63 2010-10-05 15:45:19 lgarnier Exp $
                                                   >>  28 // GEANT4 tag $Name: not supported by cvs2svn $
 27 //                                                 29 //
 28 //                                                 30 // 
 29 // Andrew Walkden  27th March 1996                 31 // Andrew Walkden  27th March 1996
 30 // OpenGL view - opens window, hard copy, etc.     32 // OpenGL view - opens window, hard copy, etc.
 31                                                    33 
                                                   >>  34 #ifdef G4VIS_BUILD_OPENGL_DRIVER
                                                   >>  35 
 32 #include "G4ios.hh"                                36 #include "G4ios.hh"
 33 #include <CLHEP/Units/SystemOfUnits.h>         << 
 34 #include "G4OpenGLViewer.hh"                       37 #include "G4OpenGLViewer.hh"
 35 #include "G4OpenGLSceneHandler.hh"                 38 #include "G4OpenGLSceneHandler.hh"
 36 #include "G4OpenGLTransform3D.hh"                  39 #include "G4OpenGLTransform3D.hh"
 37                                                <<  40 #include "G4OpenGL2PSAction.hh"
 38 #include "G4gl2ps.hh"                          << 
 39 #define GL2PS_TEXT_B  TOOLS_GL2PS_TEXT_B       << 
 40 #define GL2PS_TEXT_BL TOOLS_GL2PS_TEXT_BL      << 
 41 #define GL2PS_TEXT_BR TOOLS_GL2PS_TEXT_BR      << 
 42                                                    41 
 43 #include "G4Scene.hh"                              42 #include "G4Scene.hh"
 44 #include "G4VisExtent.hh"                          43 #include "G4VisExtent.hh"
 45 #include "G4LogicalVolume.hh"                      44 #include "G4LogicalVolume.hh"
 46 #include "G4VSolid.hh"                             45 #include "G4VSolid.hh"
 47 #include "G4Point3D.hh"                            46 #include "G4Point3D.hh"
 48 #include "G4Normal3D.hh"                           47 #include "G4Normal3D.hh"
 49 #include "G4Plane3D.hh"                            48 #include "G4Plane3D.hh"
 50 #include "G4AttHolder.hh"                          49 #include "G4AttHolder.hh"
 51 #include "G4AttCheck.hh"                           50 #include "G4AttCheck.hh"
 52 #include "G4Text.hh"                           <<  51 
                                                   >>  52 // GL2PS
                                                   >>  53 #include "Geant4_gl2ps.h"
 53                                                    54 
 54 #include <sstream>                                 55 #include <sstream>
 55 #include <string>                              << 
 56 #include <iomanip>                             << 
 57                                                    56 
 58 G4OpenGLViewer::G4OpenGLViewer (G4OpenGLSceneH     57 G4OpenGLViewer::G4OpenGLViewer (G4OpenGLSceneHandler& scene):
 59 G4VViewer (scene, -1),                             58 G4VViewer (scene, -1),
 60 fPrintColour (true),                               59 fPrintColour (true),
 61 fVectoredPs (true),                                60 fVectoredPs (true),
 62 fOpenGLSceneHandler(scene),                        61 fOpenGLSceneHandler(scene),
 63 background (G4Colour(0.,0.,0.)),                   62 background (G4Colour(0.,0.,0.)),
 64 transparency_enabled (true),                       63 transparency_enabled (true),
 65 antialiasing_enabled (false),                      64 antialiasing_enabled (false),
 66 haloing_enabled (false),                           65 haloing_enabled (false),
 67 fRot_sens(1.),                                 <<  66 fStartTime(-DBL_MAX),
 68 fPan_sens(0.01),                               <<  67 fEndTime(DBL_MAX),
 69 fWinSize_x(0),                                 <<  68 fFadeFactor(0.),
 70 fWinSize_y(0),                                 <<  69 fDisplayHeadTime(false),
 71 fDefaultExportImageFormat("pdf"),              <<  70 fDisplayHeadTimeX(-0.9),
 72 fExportImageFormat("pdf"),                     <<  71 fDisplayHeadTimeY(-0.9),
 73 fExportFilenameIndex(0),                       <<  72 fDisplayHeadTimeSize(24.),
                                                   >>  73 fDisplayHeadTimeRed(0.),
                                                   >>  74 fDisplayHeadTimeGreen(1.),
                                                   >>  75 fDisplayHeadTimeBlue(1.),
                                                   >>  76 fDisplayLightFront(false),
                                                   >>  77 fDisplayLightFrontX(0.),
                                                   >>  78 fDisplayLightFrontY(0.),
                                                   >>  79 fDisplayLightFrontZ(0.),
                                                   >>  80 fDisplayLightFrontT(0.),
                                                   >>  81 fDisplayLightFrontRed(0.),
                                                   >>  82 fDisplayLightFrontGreen(1.),
                                                   >>  83 fDisplayLightFrontBlue(0.),
 74 fPrintSizeX(-1),                                   84 fPrintSizeX(-1),
 75 fPrintSizeY(-1),                                   85 fPrintSizeY(-1),
                                                   >>  86 fPrintFilename ("G4OpenGL"),
                                                   >>  87 fPrintFilenameIndex(0),
 76 fPointSize (0),                                    88 fPointSize (0),
 77 fDefaultExportFilename("G4OpenGL"),            <<  89 fSizeHasChanged(0)
 78 fSizeHasChanged(0),                            << 
 79 fGl2psDefaultLineWith(1),                      << 
 80 fGl2psDefaultPointSize(2),                     << 
 81 fGlViewInitialized(false),                     << 
 82 fIsGettingPickInfos(false)                     << 
 83 {                                                  90 {
 84   // Make changes to view parameters for OpenG     91   // Make changes to view parameters for OpenGL...
 85   fVP.SetAutoRefresh(true);                        92   fVP.SetAutoRefresh(true);
 86   fDefaultVP.SetAutoRefresh(true);                 93   fDefaultVP.SetAutoRefresh(true);
 87   fGL2PSAction = new G4gl2ps();                << 
 88   tools_gl2ps_gl_funcs_t _funcs = {            << 
 89     (tools_glIsEnabled_func)glIsEnabled,       << 
 90     (tools_glBegin_func)glBegin,               << 
 91     (tools_glEnd_func)glEnd,                   << 
 92     (tools_glGetFloatv_func)glGetFloatv,       << 
 93     (tools_glVertex3f_func)glVertex3f,         << 
 94     (tools_glGetBooleanv_func)glGetBooleanv,   << 
 95     (tools_glGetIntegerv_func)glGetIntegerv,   << 
 96     (tools_glRenderMode_func)glRenderMode,     << 
 97     (tools_glFeedbackBuffer_func)glFeedbackBuf << 
 98     (tools_glPassThrough_func)glPassThrough    << 
 99   };                                           << 
100   fGL2PSAction->setOpenGLFunctions(&_funcs);   << 
101                                                << 
102   // add supported export image format         << 
103   addExportImageFormat("eps");                 << 
104   addExportImageFormat("ps");                  << 
105   addExportImageFormat("pdf");                 << 
106   addExportImageFormat("svg");                 << 
107                                                    94 
108   // Change the default name                   <<  95   fGL2PSAction = new G4OpenGL2PSAction();
109   fExportFilename += fDefaultExportFilename +  <<  96 
110                                                << 
111   //  glClearColor (0.0, 0.0, 0.0, 0.0);           97   //  glClearColor (0.0, 0.0, 0.0, 0.0);
112   //  glClearDepth (1.0);                          98   //  glClearDepth (1.0);
113   //  glDisable (GL_BLEND);                        99   //  glDisable (GL_BLEND);
114   //  glDisable (GL_LINE_SMOOTH);                 100   //  glDisable (GL_LINE_SMOOTH);
115   //  glDisable (GL_POLYGON_SMOOTH);              101   //  glDisable (GL_POLYGON_SMOOTH);
116                                                   102 
117 }                                                 103 }
118                                                   104 
119 G4OpenGLViewer::~G4OpenGLViewer ()             << 105 G4OpenGLViewer::~G4OpenGLViewer () {}
120 {                                              << 
121   delete fGL2PSAction;                         << 
122 }                                              << 
123                                                   106 
124 void G4OpenGLViewer::InitializeGLView ()          107 void G4OpenGLViewer::InitializeGLView () 
125 {                                                 108 {
126   if (fWinSize_x == 0) {                       << 
127     fWinSize_x = fVP.GetWindowSizeHintX();     << 
128   }                                            << 
129   if (fWinSize_y == 0) {                       << 
130     fWinSize_y = fVP.GetWindowSizeHintY();     << 
131   }                                            << 
132                                                << 
133   glClearColor (0.0, 0.0, 0.0, 0.0);              109   glClearColor (0.0, 0.0, 0.0, 0.0);
134   glClearDepth (1.0);                             110   glClearDepth (1.0);
                                                   >> 111   glDisable (GL_BLEND);
135   glDisable (GL_LINE_SMOOTH);                     112   glDisable (GL_LINE_SMOOTH);
136   glDisable (GL_POLYGON_SMOOTH);                  113   glDisable (GL_POLYGON_SMOOTH);
137                                                   114 
138 // clear the buffers and window?               << 115   fWinSize_x = fVP.GetWindowSizeHintX();
139   ClearView ();                                << 116   fWinSize_y = fVP.GetWindowSizeHintY();
140   FinishView ();                               << 117 }  
141                                                << 
142   glDepthFunc (GL_LEQUAL);                     << 
143   glDepthMask (GL_TRUE);                       << 
144                                                << 
145   glEnable (GL_BLEND);                         << 
146   glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ << 
147                                                << 
148 }                                              << 
149                                                   118 
150 void G4OpenGLViewer::ClearView () {               119 void G4OpenGLViewer::ClearView () {
151   ClearViewWithoutFlush();                     << 120 #ifdef G4DEBUG_VIS_OGL
152                                                << 121   printf("G4OpenGLViewer::ClearView\n");
153   if(!isFramebufferReady()) {                  << 122 #endif
154     return;                                    << 
155   }                                            << 
156                                                << 
157   glFlush();                                   << 
158 }                                              << 
159                                                << 
160                                                << 
161 void G4OpenGLViewer::ClearViewWithoutFlush ()  << 
162   // Ready for clear ?                         << 
163   // See : http://lists.apple.com/archives/mac << 
164   if(!isFramebufferReady()) {                  << 
165     return;                                    << 
166   }                                            << 
167                                                << 
168   glClearColor (background.GetRed(),              123   glClearColor (background.GetRed(),
169                 background.GetGreen(),         << 124     background.GetGreen(),
170                 background.GetBlue(),          << 125     background.GetBlue(),
171                 1.);                           << 126     1.);
172   glClearDepth (1.0);                             127   glClearDepth (1.0);
173   //Below line does not compile with Mesa incl << 128   //Below line does not compile with Mesa includes. 
174   //glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BU << 129   //glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
175   glClear (GL_COLOR_BUFFER_BIT);                  130   glClear (GL_COLOR_BUFFER_BIT);
176   glClear (GL_DEPTH_BUFFER_BIT);                  131   glClear (GL_DEPTH_BUFFER_BIT);
177   glClear (GL_STENCIL_BUFFER_BIT);                132   glClear (GL_STENCIL_BUFFER_BIT);
                                                   >> 133 #ifdef G4DEBUG_VIS_OGL
                                                   >> 134   printf("G4OpenGLViewer::ClearView flush\n");
                                                   >> 135 #endif
                                                   >> 136   glFlush ();
178 }                                                 137 }
179                                                   138 
180                                                   139 
181 void G4OpenGLViewer::ResizeWindow(unsigned int    140 void G4OpenGLViewer::ResizeWindow(unsigned int aWidth, unsigned int aHeight) {
182   if ((fWinSize_x != aWidth) || (fWinSize_y !=    141   if ((fWinSize_x != aWidth) || (fWinSize_y != aHeight)) {
183     fWinSize_x = aWidth;                          142     fWinSize_x = aWidth;
184     fWinSize_y = aHeight;                         143     fWinSize_y = aHeight;
185     fSizeHasChanged = true;                       144     fSizeHasChanged = true;
186   } else {                                        145   } else {
187     fSizeHasChanged = false;                      146     fSizeHasChanged = false;
188   }                                               147   }
189 }                                                 148 }
190                                                   149 
191 /**                                               150 /**
192  * Set the viewport of the scene                  151  * Set the viewport of the scene
193  * MAXIMUM SIZE is :                              152  * MAXIMUM SIZE is :
194  * GLint dims[2];                                 153  * GLint dims[2];
195  * glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);     154  * glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
196  */                                               155  */
197 void G4OpenGLViewer::ResizeGLView()               156 void G4OpenGLViewer::ResizeGLView()
198 {                                                 157 {
                                                   >> 158 #ifdef G4DEBUG_VIS_OGL
                                                   >> 159   printf("G4OpenGLViewer::ResizeGLView %d %d &:%d\n",fWinSize_x,fWinSize_y,this);
                                                   >> 160 #endif
199   // Check size                                   161   // Check size
200   GLint dims[2];                                  162   GLint dims[2];
201   dims[0] = 0;                                 << 
202   dims[1] = 0;                                 << 
203                                                << 
204   glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);      163   glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
205                                                   164 
206   if ((dims[0] !=0 ) && (dims[1] !=0)) {          165   if ((dims[0] !=0 ) && (dims[1] !=0)) {
207                                                   166 
208     if (fWinSize_x > (unsigned)dims[0]) {         167     if (fWinSize_x > (unsigned)dims[0]) {
209       G4cerr << "Try to resize view greater th << 168       G4cerr << "Try to resize view greater than max X viewport dimension. Desired size "<<dims[0] <<" is resize to "<<  dims[0] << G4endl;
210       fWinSize_x = dims[0];                       169       fWinSize_x = dims[0];
211     }                                             170     }
212     if (fWinSize_y > (unsigned)dims[1]) {         171     if (fWinSize_y > (unsigned)dims[1]) {
213       G4cerr << "Try to resize view greater th << 172       G4cerr << "Try to resize view greater than max Y viewport dimension. Desired size "<<dims[0] <<" is resize to "<<  dims[1] << G4endl;
214       fWinSize_y = dims[1];                       173       fWinSize_y = dims[1];
215     }                                             174     }
216   }                                               175   }
217                                                   176     
218   glViewport(0, 0, fWinSize_x,fWinSize_y);        177   glViewport(0, 0, fWinSize_x,fWinSize_y);   
219                                                   178 
220                                                   179 
221 }                                                 180 }
222                                                   181 
223                                                   182 
224 void G4OpenGLViewer::SetView () {                 183 void G4OpenGLViewer::SetView () {
225   // if getting pick infos, should not resize  << 184 
226   if (fIsGettingPickInfos) return;             << 
227                                                << 
228   if (!fSceneHandler.GetScene()) {                185   if (!fSceneHandler.GetScene()) {
229     return;                                       186     return;
230   }                                               187   }
231   // Calculates view representation based on e    188   // Calculates view representation based on extent of object being
232   // viewed and (initial) viewpoint.  (Note: i    189   // viewed and (initial) viewpoint.  (Note: it can change later due
233   // to user interaction via visualization sys    190   // to user interaction via visualization system's GUI.)
234                                                   191   
235   // Lighting.                                    192   // Lighting.
236   GLfloat lightPosition [4];                      193   GLfloat lightPosition [4];
237   lightPosition [0] = fVP.GetActualLightpointD    194   lightPosition [0] = fVP.GetActualLightpointDirection().x();
238   lightPosition [1] = fVP.GetActualLightpointD    195   lightPosition [1] = fVP.GetActualLightpointDirection().y();
239   lightPosition [2] = fVP.GetActualLightpointD    196   lightPosition [2] = fVP.GetActualLightpointDirection().z();
240   lightPosition [3] = 0.;                         197   lightPosition [3] = 0.;
241   // Light position is "true" light direction,    198   // Light position is "true" light direction, so must come after gluLookAt.
242   GLfloat ambient [] = { 0.2f, 0.2f, 0.2f, 1.f << 199   GLfloat ambient [] = { 0.2, 0.2, 0.2, 1.};
243   GLfloat diffuse [] = { 0.8f, 0.8f, 0.8f, 1.f << 200   GLfloat diffuse [] = { 0.8, 0.8, 0.8, 1.};
244   glEnable (GL_LIGHT0);                           201   glEnable (GL_LIGHT0);
245   glLightfv (GL_LIGHT0, GL_AMBIENT, ambient);     202   glLightfv (GL_LIGHT0, GL_AMBIENT, ambient);
246   glLightfv (GL_LIGHT0, GL_DIFFUSE, diffuse);     203   glLightfv (GL_LIGHT0, GL_DIFFUSE, diffuse);
247                                                   204   
248   G4double ratioX = 1;                            205   G4double ratioX = 1;
249   G4double ratioY = 1;                            206   G4double ratioY = 1;
250   if (fWinSize_y > fWinSize_x) {                  207   if (fWinSize_y > fWinSize_x) {
251     ratioX = ((G4double)fWinSize_y) / ((G4doub    208     ratioX = ((G4double)fWinSize_y) / ((G4double)fWinSize_x);
252   }                                               209   }
253   if (fWinSize_x > fWinSize_y) {                  210   if (fWinSize_x > fWinSize_y) {
254     ratioY = ((G4double)fWinSize_x) / ((G4doub    211     ratioY = ((G4double)fWinSize_x) / ((G4double)fWinSize_y);
255   }                                               212   }
256                                                   213   
257   // Get radius of scene, etc.                    214   // Get radius of scene, etc.
258   // Note that this procedure properly takes i    215   // Note that this procedure properly takes into account zoom, dolly and pan.
259   const G4Point3D targetPoint                     216   const G4Point3D targetPoint
260     = fSceneHandler.GetScene()->GetStandardTar    217     = fSceneHandler.GetScene()->GetStandardTargetPoint()
261     + fVP.GetCurrentTargetPoint ();               218     + fVP.GetCurrentTargetPoint ();
262   G4double radius = fSceneHandler.GetScene()->    219   G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
263   if(radius<=0.) radius = 1.;                     220   if(radius<=0.) radius = 1.;
264   const G4double cameraDistance = fVP.GetCamer    221   const G4double cameraDistance = fVP.GetCameraDistance (radius);
265   const G4Point3D cameraPosition =                222   const G4Point3D cameraPosition =
266     targetPoint + cameraDistance * fVP.GetView    223     targetPoint + cameraDistance * fVP.GetViewpointDirection().unit();
267   const GLdouble pnear  = fVP.GetNearDistance     224   const GLdouble pnear  = fVP.GetNearDistance (cameraDistance, radius);
268   const GLdouble pfar   = fVP.GetFarDistance      225   const GLdouble pfar   = fVP.GetFarDistance  (cameraDistance, pnear, radius);
269   const GLdouble right  = fVP.GetFrontHalfHeig    226   const GLdouble right  = fVP.GetFrontHalfHeight (pnear, radius) * ratioY;
270   const GLdouble left   = -right;                 227   const GLdouble left   = -right;
271   const GLdouble top    = fVP.GetFrontHalfHeig    228   const GLdouble top    = fVP.GetFrontHalfHeight (pnear, radius) * ratioX;
272   const GLdouble bottom = -top;                   229   const GLdouble bottom = -top;
273                                                   230   
274   // FIXME                                        231   // FIXME
275   ResizeGLView();                                 232   ResizeGLView();
276   //SHOULD SetWindowsSizeHint()...                233   //SHOULD SetWindowsSizeHint()...
277                                                   234 
278   glMatrixMode (GL_PROJECTION); // set up Frus    235   glMatrixMode (GL_PROJECTION); // set up Frustum.
279   glLoadIdentity();                               236   glLoadIdentity();
280                                                   237 
281   const G4Vector3D scaleFactor = fVP.GetScaleF    238   const G4Vector3D scaleFactor = fVP.GetScaleFactor();
282   glScaled(scaleFactor.x(),scaleFactor.y(),sca    239   glScaled(scaleFactor.x(),scaleFactor.y(),scaleFactor.z());
283                                                   240   
284   if (fVP.GetFieldHalfAngle() == 0.) {            241   if (fVP.GetFieldHalfAngle() == 0.) {
285     g4GlOrtho (left, right, bottom, top, pnear << 242     glOrtho (left, right, bottom, top, pnear, pfar);
286   }                                               243   }
287   else {                                          244   else {
288     g4GlFrustum (left, right, bottom, top, pne << 245     glFrustum (left, right, bottom, top, pnear, pfar);
289   }                                               246   }  
290                                                   247 
291   glMatrixMode (GL_MODELVIEW); // apply furthe    248   glMatrixMode (GL_MODELVIEW); // apply further transformations to scene.
292   glLoadIdentity();                               249   glLoadIdentity();
293                                                   250   
294   const G4Normal3D& upVector = fVP.GetUpVector    251   const G4Normal3D& upVector = fVP.GetUpVector ();  
295   G4Point3D gltarget;                             252   G4Point3D gltarget;
296   if (cameraDistance > 1.e-6 * radius) {          253   if (cameraDistance > 1.e-6 * radius) {
297     gltarget = targetPoint;                       254     gltarget = targetPoint;
298   }                                               255   }
299   else {                                          256   else {
300     gltarget = targetPoint - radius * fVP.GetV    257     gltarget = targetPoint - radius * fVP.GetViewpointDirection().unit();
301   }                                               258   }
302                                                   259 
303   const G4Point3D& pCamera = cameraPosition;      260   const G4Point3D& pCamera = cameraPosition;  // An alias for brevity.
                                                   >> 261   gluLookAt (pCamera.x(),  pCamera.y(),  pCamera.z(),       // Viewpoint.
                                                   >> 262        gltarget.x(), gltarget.y(), gltarget.z(),      // Target point.
                                                   >> 263        upVector.x(), upVector.y(), upVector.z());     // Up vector.
304                                                   264 
305   g4GluLookAt (pCamera.x(),  pCamera.y(),  pCa << 
306              gltarget.x(), gltarget.y(), gltar << 
307              upVector.x(), upVector.y(), upVec << 
308   // Light position is "true" light direction,    265   // Light position is "true" light direction, so must come after gluLookAt.
309   glLightfv (GL_LIGHT0, GL_POSITION, lightPosi    266   glLightfv (GL_LIGHT0, GL_POSITION, lightPosition);
310                                                   267 
311   // The idea is to use back-to-back clipping  << 268   // OpenGL no longer seems to reconstruct clipped edges, so, when the
312   // down to just a few pixels, which can make << 269   // BooleanProcessor is up to it, abandon this and use generic
313   // now, comment this out and use the generic << 270   // clipping in G4OpenGLSceneHandler::CreateSectionPolyhedron.  Also,
314   // G4VSolid* G4OpenGLSceneHandler::CreateSec << 271   // force kernel visit on change of clipping plane in
315   // { return G4VSceneHandler::CreateSectionSo << 272   // G4OpenGLStoredViewer::CompareForKernelVisit.
316 //  if (fVP.IsSection () ) {  // pair of back  << 273   //if (fVP.IsSection () ) {  // pair of back to back clip planes.
317 //    const G4Plane3D& sp = fVP.GetSectionPlan << 274   if (false) {  // pair of back to back clip planes.
318 //    double sArray[4];                        << 275     const G4Plane3D& s = fVP.GetSectionPlane ();
319 //    sArray[0] = sp.a();                      << 276     double sArray[4];
320 //    sArray[1] = sp.b();                      << 277     sArray[0] = s.a();
321 //    sArray[2] = sp.c();                      << 278     sArray[1] = s.b();
322 //    sArray[3] = sp.d() + radius * 1.e-05;    << 279     sArray[2] = s.c();
323 //    glClipPlane (GL_CLIP_PLANE0, sArray);    << 280     sArray[3] = s.d() + radius * 1.e-05;
324 //    glEnable (GL_CLIP_PLANE0);               << 281     glClipPlane (GL_CLIP_PLANE0, sArray);
325 //    sArray[0] = -sp.a();                     << 282     glEnable (GL_CLIP_PLANE0);
326 //    sArray[1] = -sp.b();                     << 283     sArray[0] = -s.a();
327 //    sArray[2] = -sp.c();                     << 284     sArray[1] = -s.b();
328 //    sArray[3] = -sp.d() + radius * 1.e-05;   << 285     sArray[2] = -s.c();
329 //    glClipPlane (GL_CLIP_PLANE1, sArray);    << 286     sArray[3] = -s.d() + radius * 1.e-05;
330 //    glEnable (GL_CLIP_PLANE1);               << 287     glClipPlane (GL_CLIP_PLANE1, sArray);
331 //  } else {                                   << 288     glEnable (GL_CLIP_PLANE1);
332 //    glDisable (GL_CLIP_PLANE0);              << 289   } else {
333 //    glDisable (GL_CLIP_PLANE1);              << 290     glDisable (GL_CLIP_PLANE0);
334 //  }                                          << 291     glDisable (GL_CLIP_PLANE1);
335                                                << 292   }
336   // What we call intersection of cutaways is  << 293 
337   // just keep cutting.  Unions are more trick << 
338   // multiple passes and this is handled in    << 
339   // G4OpenGLImmediate/StoredViewer::ProcessVi << 
340   const G4Planes& cutaways = fVP.GetCutawayPla    294   const G4Planes& cutaways = fVP.GetCutawayPlanes();
341   size_t nPlanes = cutaways.size();               295   size_t nPlanes = cutaways.size();
342   if (fVP.IsCutaway() &&                          296   if (fVP.IsCutaway() &&
343       fVP.GetCutawayMode() == G4ViewParameters << 297       fVP.GetCutawayMode() == G4ViewParameters::cutawayIntersection &&
                                                   >> 298       nPlanes > 0) {
344     double a[4];                                  299     double a[4];
345     a[0] = cutaways[0].a();                       300     a[0] = cutaways[0].a();
346     a[1] = cutaways[0].b();                       301     a[1] = cutaways[0].b();
347     a[2] = cutaways[0].c();                       302     a[2] = cutaways[0].c();
348     a[3] = cutaways[0].d();                       303     a[3] = cutaways[0].d();
349     glClipPlane (GL_CLIP_PLANE2, a);              304     glClipPlane (GL_CLIP_PLANE2, a);
350     glEnable (GL_CLIP_PLANE2);                    305     glEnable (GL_CLIP_PLANE2);
351     if (nPlanes > 1) {                            306     if (nPlanes > 1) {
352       a[0] = cutaways[1].a();                     307       a[0] = cutaways[1].a();
353       a[1] = cutaways[1].b();                     308       a[1] = cutaways[1].b();
354       a[2] = cutaways[1].c();                     309       a[2] = cutaways[1].c();
355       a[3] = cutaways[1].d();                     310       a[3] = cutaways[1].d();
356       glClipPlane (GL_CLIP_PLANE3, a);            311       glClipPlane (GL_CLIP_PLANE3, a);
357       glEnable (GL_CLIP_PLANE3);                  312       glEnable (GL_CLIP_PLANE3);
358     }                                             313     }
359     if (nPlanes > 2) {                            314     if (nPlanes > 2) {
360       a[0] = cutaways[2].a();                     315       a[0] = cutaways[2].a();
361       a[1] = cutaways[2].b();                     316       a[1] = cutaways[2].b();
362       a[2] = cutaways[2].c();                     317       a[2] = cutaways[2].c();
363       a[3] = cutaways[2].d();                     318       a[3] = cutaways[2].d();
364       glClipPlane (GL_CLIP_PLANE4, a);            319       glClipPlane (GL_CLIP_PLANE4, a);
365       glEnable (GL_CLIP_PLANE4);                  320       glEnable (GL_CLIP_PLANE4);
366     }                                             321     }
367   } else {                                        322   } else {
368     glDisable (GL_CLIP_PLANE2);                   323     glDisable (GL_CLIP_PLANE2);
369     glDisable (GL_CLIP_PLANE3);                   324     glDisable (GL_CLIP_PLANE3);
370     glDisable (GL_CLIP_PLANE4);                   325     glDisable (GL_CLIP_PLANE4);
371   }                                               326   }
372                                                   327 
373   // Background.                                  328   // Background.
374   background = fVP.GetBackgroundColour ();        329   background = fVP.GetBackgroundColour ();
375                                                   330 
376 }                                                 331 }
377                                                   332 
378                                                << 
379                                                << 
380 void G4OpenGLViewer::ResetView () {            << 
381   G4VViewer::ResetView();                      << 
382   fRot_sens = 1;                               << 
383   fPan_sens = 0.01;                            << 
384 }                                              << 
385                                                << 
386                                                << 
387 void G4OpenGLViewer::HaloingFirstPass () {        333 void G4OpenGLViewer::HaloingFirstPass () {
388                                                   334   
389   //To perform haloing, first Draw all informa    335   //To perform haloing, first Draw all information to the depth buffer
390   //alone, using a chunky line width, and then    336   //alone, using a chunky line width, and then Draw all info again, to
391   //the colour buffer, setting a thinner line     337   //the colour buffer, setting a thinner line width an the depth testing 
392   //function to less than or equal, so if two     338   //function to less than or equal, so if two lines cross, the one 
393   //passing behind the other will not pass the    339   //passing behind the other will not pass the depth test, and so not
394   //get rendered either side of the infront li    340   //get rendered either side of the infront line for a short distance.
395                                                   341 
396   //First, disable writing to the colo(u)r buf    342   //First, disable writing to the colo(u)r buffer...
397   glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, G    343   glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
398                                                   344 
399   //Now enable writing to the depth buffer...     345   //Now enable writing to the depth buffer...
400   glDepthMask (GL_TRUE);                          346   glDepthMask (GL_TRUE);
401   glDepthFunc (GL_LESS);                          347   glDepthFunc (GL_LESS);
402   glClearDepth (1.0);                             348   glClearDepth (1.0);
403                                                   349 
404   //Finally, set the line width to something w    350   //Finally, set the line width to something wide...
405   ChangeLineWidth(3.0);                        << 351   glLineWidth (3.0);
406                                                   352 
407 }                                                 353 }
408                                                   354 
409 void G4OpenGLViewer::HaloingSecondPass () {       355 void G4OpenGLViewer::HaloingSecondPass () {
410                                                   356 
411   //And finally, turn the colour buffer back o    357   //And finally, turn the colour buffer back on with a sesible line width...
412   glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_T    358   glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
413   glDepthFunc (GL_LEQUAL);                        359   glDepthFunc (GL_LEQUAL);
414   ChangeLineWidth(1.0);                        << 360   glLineWidth (1.0);
415                                                   361 
416 }                                                 362 }
417                                                   363 
418 G4String G4OpenGLViewer::Pick(GLdouble x, GLdo << 364 void G4OpenGLViewer::Pick(GLdouble x, GLdouble y)
419 {                                                 365 {
420   const std::vector < G4OpenGLViewerPickMap* > << 366   //G4cout << "X: " << x << ", Y: " << y << G4endl;
421   G4String txt = "";                           << 
422   if (pickMap.size() == 0) {                   << 
423 //        txt += "No hits recorded.";;         << 
424   } else {                                     << 
425     for (unsigned int a=0; a < pickMap.size(); << 
426       if (pickMap[a]->getAttributes().size() > << 
427         txt += pickMap[a]->print();            << 
428       }                                        << 
429     }                                          << 
430   }                                            << 
431   return txt;                                  << 
432 }                                              << 
433                                                << 
434 const std::vector < G4OpenGLViewerPickMap* > & << 
435 {                                              << 
436   static std::vector < G4OpenGLViewerPickMap*  << 
437   for (auto pickMap: pickMapVector) {          << 
438     delete pickMap;                            << 
439   }                                            << 
440   pickMapVector.clear();                       << 
441                                                << 
442   const G4int BUFSIZE = 512;                      367   const G4int BUFSIZE = 512;
443   GLuint selectBuffer[BUFSIZE];                   368   GLuint selectBuffer[BUFSIZE];
444   glSelectBuffer(BUFSIZE, selectBuffer);          369   glSelectBuffer(BUFSIZE, selectBuffer);
445   glRenderMode(GL_SELECT);                        370   glRenderMode(GL_SELECT);
446   glInitNames();                                  371   glInitNames();
447   glPushName(0);                                  372   glPushName(0);
448   glMatrixMode(GL_PROJECTION);                    373   glMatrixMode(GL_PROJECTION);
449   G4double currentProjectionMatrix[16];           374   G4double currentProjectionMatrix[16];
450   glGetDoublev(GL_PROJECTION_MATRIX, currentPr    375   glGetDoublev(GL_PROJECTION_MATRIX, currentProjectionMatrix);
451   glPushMatrix();                                 376   glPushMatrix();
452   glLoadIdentity();                               377   glLoadIdentity();
453   GLint viewport[4];                              378   GLint viewport[4];
454   glGetIntegerv(GL_VIEWPORT, viewport);           379   glGetIntegerv(GL_VIEWPORT, viewport);
455 /*  G4cout                                     << 
456   << "viewport, x,y: "                         << 
457   << viewport[0] << ',' << viewport[1] << ','  << 
458   << ", " << x << ',' << y                     << 
459   << G4endl;                                   << 
460 */                                             << 
461   fIsGettingPickInfos = true;                  << 
462   // Define 5x5 pixel pick area                   380   // Define 5x5 pixel pick area
463   g4GluPickMatrix(x, viewport[3] - y, 5., 5.,  << 381   gluPickMatrix(x, viewport[3] - y, 5., 5., viewport);
464   glMultMatrixd(currentProjectionMatrix);         382   glMultMatrixd(currentProjectionMatrix);
465   glMatrixMode(GL_MODELVIEW);                     383   glMatrixMode(GL_MODELVIEW);
466   DrawView();                                     384   DrawView();
467   GLint hits = glRenderMode(GL_RENDER);           385   GLint hits = glRenderMode(GL_RENDER);
468   fIsGettingPickInfos = false;                 << 386   if (hits < 0)
469   if (hits < 0) {                              << 
470     G4cout << "Too many hits.  Zoom in to redu    387     G4cout << "Too many hits.  Zoom in to reduce overlaps." << G4endl;
471     goto restoreMatrices;                      << 388   else if (hits > 0) {
472   }                                            << 389     //G4cout << hits << " hit(s)" << G4endl;
473   if (hits > 0) {                              << 
474     GLuint* p = selectBuffer;                     390     GLuint* p = selectBuffer;
475     for (GLint i = 0; i < hits; ++i) {            391     for (GLint i = 0; i < hits; ++i) {
476       GLuint nnames = *p++;                       392       GLuint nnames = *p++;
477       // This bit of debug code or...          << 393       p++; //OR GLuint zmin = *p++;
478       //GLuint zmin = *p++;                    << 394       p++; //OR GLuint zmax = *p++;
479       //GLuint zmax = *p++;                    << 
480       //G4cout << "Hit " << i << ": " << nname    395       //G4cout << "Hit " << i << ": " << nnames << " names"
481       //       << "\nzmin: " << zmin << ", zma << 396       //     << "\nzmin: " << zmin << ", zmax: " << zmax << G4endl;
482       // ...just increment the pointer         << 
483       p++;                                     << 
484       p++;                                     << 
485       for (GLuint j = 0; j < nnames; ++j) {       397       for (GLuint j = 0; j < nnames; ++j) {
486         GLuint name = *p++;                    << 398   GLuint name = *p++;
                                                   >> 399   //G4cout << "Name " << j << ": PickName: " << name << G4endl;
487   std::map<GLuint, G4AttHolder*>::iterator ite    400   std::map<GLuint, G4AttHolder*>::iterator iter =
488     fOpenGLSceneHandler.fPickMap.find(name);      401     fOpenGLSceneHandler.fPickMap.find(name);
489   if (iter != fOpenGLSceneHandler.fPickMap.end    402   if (iter != fOpenGLSceneHandler.fPickMap.end()) {
490     G4AttHolder* attHolder = iter->second;        403     G4AttHolder* attHolder = iter->second;
491     if(attHolder && attHolder->GetAttDefs().si    404     if(attHolder && attHolder->GetAttDefs().size()) {
492       for (size_t iAtt = 0;                    << 405       for (size_t i = 0; i < attHolder->GetAttDefs().size(); ++i) {
493      iAtt < attHolder->GetAttDefs().size(); ++ << 406         G4cout << G4AttCheck(attHolder->GetAttValues()[i],
494               std::ostringstream oss;          << 407            attHolder->GetAttDefs()[i]);
495         oss << G4AttCheck(attHolder->GetAttVal << 408       }
496                                 attHolder->Get << 409     }
497               G4OpenGLViewerPickMap* pickMap = << 410   }
498 //              G4cout                         << 
499 //              << "i,j, attHolder->GetAttDefs << 
500 //              << i << ',' << j               << 
501 //              << ", " << attHolder->GetAttDe << 
502 //              << G4endl;                     << 
503 //              G4cout << "G4OpenGLViewer::Get << 
504               pickMap->addAttributes(oss.str() << 
505               pickMap->setHitNumber(i);        << 
506               pickMap->setSubHitNumber(j);     << 
507               pickMap->setPickName(name);      << 
508               pickMapVector.push_back(pickMap) << 
509             }                                  << 
510           }                                    << 
511         }                                      << 
512       }                                           411       }
                                                   >> 412       G4cout << G4endl;
513     }                                             413     }
514   }                                               414   }
515                                                << 
516 restoreMatrices:                               << 
517   glMatrixMode(GL_PROJECTION);                    415   glMatrixMode(GL_PROJECTION);
518   glPopMatrix();                                  416   glPopMatrix();
519   glMatrixMode(GL_MODELVIEW);                     417   glMatrixMode(GL_MODELVIEW);
520                                                << 
521   return pickMapVector;                        << 
522 }                                                 418 }
523                                                   419 
524 GLubyte* G4OpenGLViewer::grabPixels            << 420 
525 (int inColor, unsigned int width, unsigned int << 421 
                                                   >> 422 
                                                   >> 423 GLubyte* G4OpenGLViewer::grabPixels (int inColor, unsigned int width, unsigned int height) {
526                                                   424   
527   GLubyte* buffer;                                425   GLubyte* buffer;
528   GLint swapbytes, lsbfirst, rowlength;           426   GLint swapbytes, lsbfirst, rowlength;
529   GLint skiprows, skippixels, alignment;          427   GLint skiprows, skippixels, alignment;
530   GLenum format;                                  428   GLenum format;
531   int size;                                       429   int size;
532                                                   430 
533   if (inColor) {                                  431   if (inColor) {
534     format = GL_RGB;                              432     format = GL_RGB;
535     size = width*height*3;                        433     size = width*height*3;
536   } else {                                        434   } else {
537     format = GL_LUMINANCE;                        435     format = GL_LUMINANCE;
538     size = width*height*1;                        436     size = width*height*1;
539   }                                               437   }
540                                                   438 
541   buffer = new GLubyte[size];                     439   buffer = new GLubyte[size];
542   if (buffer == NULL)                             440   if (buffer == NULL)
543     return NULL;                                  441     return NULL;
544                                                   442 
545   glGetIntegerv (GL_UNPACK_SWAP_BYTES, &swapby    443   glGetIntegerv (GL_UNPACK_SWAP_BYTES, &swapbytes);
546   glGetIntegerv (GL_UNPACK_LSB_FIRST, &lsbfirs    444   glGetIntegerv (GL_UNPACK_LSB_FIRST, &lsbfirst);
547   glGetIntegerv (GL_UNPACK_ROW_LENGTH, &rowlen    445   glGetIntegerv (GL_UNPACK_ROW_LENGTH, &rowlength);
548                                                   446 
549   glGetIntegerv (GL_UNPACK_SKIP_ROWS, &skiprow    447   glGetIntegerv (GL_UNPACK_SKIP_ROWS, &skiprows);
550   glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &skipp    448   glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &skippixels);
551   glGetIntegerv (GL_UNPACK_ALIGNMENT, &alignme    449   glGetIntegerv (GL_UNPACK_ALIGNMENT, &alignment);
552                                                   450 
553   glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALS    451   glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
554   glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE    452   glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
555   glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);        453   glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
556                                                   454 
557   glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);         455   glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
558   glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);       456   glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
559   glPixelStorei (GL_UNPACK_ALIGNMENT, 1);         457   glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
560                                                   458 
561   glReadBuffer(GL_FRONT);                         459   glReadBuffer(GL_FRONT);
562   glReadPixels (0, 0, (GLsizei)width, (GLsizei    460   glReadPixels (0, 0, (GLsizei)width, (GLsizei)height, format, GL_UNSIGNED_BYTE, (GLvoid*) buffer);
563                                                   461 
564   glPixelStorei (GL_UNPACK_SWAP_BYTES, swapbyt    462   glPixelStorei (GL_UNPACK_SWAP_BYTES, swapbytes);
565   glPixelStorei (GL_UNPACK_LSB_FIRST, lsbfirst    463   glPixelStorei (GL_UNPACK_LSB_FIRST, lsbfirst);
566   glPixelStorei (GL_UNPACK_ROW_LENGTH, rowleng    464   glPixelStorei (GL_UNPACK_ROW_LENGTH, rowlength);
567                                                   465   
568   glPixelStorei (GL_UNPACK_SKIP_ROWS, skiprows    466   glPixelStorei (GL_UNPACK_SKIP_ROWS, skiprows);
569   glPixelStorei (GL_UNPACK_SKIP_PIXELS, skippi    467   glPixelStorei (GL_UNPACK_SKIP_PIXELS, skippixels);
570   glPixelStorei (GL_UNPACK_ALIGNMENT, alignmen    468   glPixelStorei (GL_UNPACK_ALIGNMENT, alignment);
571                                                   469   
572   return buffer;                                  470   return buffer;
573 }                                                 471 }
574                                                   472 
                                                   >> 473 void G4OpenGLViewer::printEPS() {
                                                   >> 474   bool res;
                                                   >> 475 #ifdef G4DEBUG_VIS_OGL
                                                   >> 476   printf("G4OpenGLViewer::printEPS file:%s Vec:%d Name:%s\n",getRealPrintFilename().c_str(),fVectoredPs,GetName().c_str());
                                                   >> 477 #endif
                                                   >> 478 
                                                   >> 479   // Change the LC_NUMERIC value in order to have "." separtor and not ","
                                                   >> 480   // This case is only useful for French, Canadien...
                                                   >> 481   char* oldLocale = (char*)(malloc(strlen(setlocale(LC_NUMERIC,NULL))+1));
                                                   >> 482   if(oldLocale!=NULL) strcpy(oldLocale,setlocale(LC_NUMERIC,NULL));
                                                   >> 483   setlocale(LC_NUMERIC,"C");
                                                   >> 484 
                                                   >> 485   if (fVectoredPs) {
                                                   >> 486     res = printVectoredEPS();
                                                   >> 487   } else {
                                                   >> 488     res = printNonVectoredEPS();
                                                   >> 489   }
                                                   >> 490 
                                                   >> 491   // restore the local
                                                   >> 492   if (oldLocale) {
                                                   >> 493     setlocale(LC_NUMERIC,oldLocale);
                                                   >> 494     free(oldLocale);
                                                   >> 495   }
                                                   >> 496 
                                                   >> 497   if (res == false) {
                                                   >> 498     G4cerr << "Error while saving file... "<<getRealPrintFilename().c_str()<< G4endl;
                                                   >> 499   } else {
                                                   >> 500     G4cout << "File "<<getRealPrintFilename().c_str()<<" has been saved " << G4endl;
                                                   >> 501   }
                                                   >> 502 
                                                   >> 503   // increment index if necessary
                                                   >> 504   if ( fPrintFilenameIndex != -1) {
                                                   >> 505     fPrintFilenameIndex++;
                                                   >> 506   }
                                                   >> 507 
                                                   >> 508 #ifdef G4DEBUG_VIS_OGL
                                                   >> 509   printf("G4OpenGLViewer::printEPS END\n");
                                                   >> 510 #endif
                                                   >> 511 }
                                                   >> 512 
575 bool G4OpenGLViewer::printVectoredEPS() {         513 bool G4OpenGLViewer::printVectoredEPS() {
576   return printGl2PS();                            514   return printGl2PS();
577 }                                                 515 }
578                                                   516 
579 bool G4OpenGLViewer::printNonVectoredEPS () {     517 bool G4OpenGLViewer::printNonVectoredEPS () {
580                                                   518 
581   int width = getRealExportWidth();            << 519   int width = getRealPrintSizeX();
582   int height = getRealExportHeight();          << 520   int height = getRealPrintSizeY();
583                                                   521 
                                                   >> 522 #ifdef G4DEBUG_VIS_OGL
                                                   >> 523   printf("G4OpenGLViewer::printNonVectoredEPS file:%s Vec:%d X:%d Y:%d col:%d fWinX:%d fWinY:%d\n",getRealPrintFilename().c_str(),fVectoredPs,width,height,fPrintColour,fWinSize_x,fWinSize_y);
                                                   >> 524 #endif
584   FILE* fp;                                       525   FILE* fp;
585   GLubyte* pixels;                                526   GLubyte* pixels;
586   GLubyte* curpix;                                527   GLubyte* curpix;
587   int components, pos, i;                         528   int components, pos, i;
588                                                   529 
589   pixels = grabPixels (fPrintColour, width, he    530   pixels = grabPixels (fPrintColour, width, height);
590                                                   531 
591   if (pixels == NULL) {                           532   if (pixels == NULL) {
592       G4cerr << "Failed to get pixels from Ope    533       G4cerr << "Failed to get pixels from OpenGl viewport" << G4endl;
593     return false;                                 534     return false;
594   }                                               535   }
595   if (fPrintColour) {                             536   if (fPrintColour) {
596     components = 3;                               537     components = 3;
597   } else {                                        538   } else {
598     components = 1;                               539     components = 1;
599   }                                               540   }
600   std::string name = getRealPrintFilename();      541   std::string name = getRealPrintFilename();
601   fp = fopen (name.c_str(), "w");                 542   fp = fopen (name.c_str(), "w");
602   if (fp == NULL) {                               543   if (fp == NULL) {
603     G4cerr << "Can't open filename " << name.c    544     G4cerr << "Can't open filename " << name.c_str() << G4endl;
604     return false;                                 545     return false;
605   }                                               546   }
606                                                   547   
607   fprintf (fp, "%%!PS-Adobe-2.0 EPSF-1.2\n");     548   fprintf (fp, "%%!PS-Adobe-2.0 EPSF-1.2\n");
608   fprintf (fp, "%%%%Title: %s\n", name.c_str()    549   fprintf (fp, "%%%%Title: %s\n", name.c_str());
609   fprintf (fp, "%%%%Creator: OpenGL pixmap ren    550   fprintf (fp, "%%%%Creator: OpenGL pixmap render output\n");
610   fprintf (fp, "%%%%BoundingBox: 0 0 %d %d\n",    551   fprintf (fp, "%%%%BoundingBox: 0 0 %d %d\n", width, height);
611   fprintf (fp, "%%%%EndComments\n");              552   fprintf (fp, "%%%%EndComments\n");
612   fprintf (fp, "gsave\n");                        553   fprintf (fp, "gsave\n");
613   fprintf (fp, "/bwproc {\n");                    554   fprintf (fp, "/bwproc {\n");
614   fprintf (fp, "    rgbproc\n");                  555   fprintf (fp, "    rgbproc\n");
615   fprintf (fp, "    dup length 3 idiv string 0    556   fprintf (fp, "    dup length 3 idiv string 0 3 0 \n");
616   fprintf (fp, "    5 -1 roll {\n");              557   fprintf (fp, "    5 -1 roll {\n");
617   fprintf (fp, "    add 2 1 roll 1 sub dup 0 e    558   fprintf (fp, "    add 2 1 roll 1 sub dup 0 eq\n");
618   fprintf (fp, "    { pop 3 idiv 3 -1 roll dup    559   fprintf (fp, "    { pop 3 idiv 3 -1 roll dup 4 -1 roll dup\n");
619   fprintf (fp, "       3 1 roll 5 -1 roll } pu    560   fprintf (fp, "       3 1 roll 5 -1 roll } put 1 add 3 0 \n");
620   fprintf (fp, "    { 2 1 roll } ifelse\n");      561   fprintf (fp, "    { 2 1 roll } ifelse\n");
621   fprintf (fp, "    }forall\n");                  562   fprintf (fp, "    }forall\n");
622   fprintf (fp, "    pop pop pop\n");              563   fprintf (fp, "    pop pop pop\n");
623   fprintf (fp, "} def\n");                        564   fprintf (fp, "} def\n");
624   fprintf (fp, "systemdict /colorimage known n    565   fprintf (fp, "systemdict /colorimage known not {\n");
625   fprintf (fp, "   /colorimage {\n");             566   fprintf (fp, "   /colorimage {\n");
626   fprintf (fp, "       pop\n");                   567   fprintf (fp, "       pop\n");
627   fprintf (fp, "       pop\n");                   568   fprintf (fp, "       pop\n");
628   fprintf (fp, "       /rgbproc exch def\n");     569   fprintf (fp, "       /rgbproc exch def\n");
629   fprintf (fp, "       { bwproc } image\n");      570   fprintf (fp, "       { bwproc } image\n");
630   fprintf (fp, "   }  def\n");                    571   fprintf (fp, "   }  def\n");
631   fprintf (fp, "} if\n");                         572   fprintf (fp, "} if\n");
632   fprintf (fp, "/picstr %d string def\n", widt    573   fprintf (fp, "/picstr %d string def\n", width * components);
633   fprintf (fp, "%d %d scale\n", width, height)    574   fprintf (fp, "%d %d scale\n", width, height);
634   fprintf (fp, "%d %d %d\n", width, height, 8)    575   fprintf (fp, "%d %d %d\n", width, height, 8);
635   fprintf (fp, "[%d 0 0 %d 0 0]\n", width, hei    576   fprintf (fp, "[%d 0 0 %d 0 0]\n", width, height);
636   fprintf (fp, "{currentfile picstr readhexstr    577   fprintf (fp, "{currentfile picstr readhexstring pop}\n");
637   fprintf (fp, "false %d\n", components);         578   fprintf (fp, "false %d\n", components);
638   fprintf (fp, "colorimage\n");                   579   fprintf (fp, "colorimage\n");
639                                                   580   
640   curpix = (GLubyte*) pixels;                     581   curpix = (GLubyte*) pixels;
641   pos = 0;                                        582   pos = 0;
642   for (i = width*height*components; i>0; i--)     583   for (i = width*height*components; i>0; i--) {
643     fprintf (fp, "%02hx ", (unsigned short)(*( << 584     fprintf (fp, "%02hx ", *(curpix++));
644     if (++pos >= 32) {                            585     if (++pos >= 32) {
645       fprintf (fp, "\n");                         586       fprintf (fp, "\n");
646       pos = 0;                                    587       pos = 0; 
647     }                                             588     }
648   }                                               589   }
649   if (pos)                                        590   if (pos)
650     fprintf (fp, "\n");                           591     fprintf (fp, "\n");
651                                                   592 
652   fprintf (fp, "grestore\n");                     593   fprintf (fp, "grestore\n");
653   fprintf (fp, "showpage\n");                     594   fprintf (fp, "showpage\n");
654   delete [] pixels;                            << 595   delete pixels;
655   fclose (fp);                                    596   fclose (fp);
656                                                   597 
657   // Reset for next time (useful if size chang << 598   // Reset for next time (useful is size change)
658   //  fPrintSizeX = -1;                           599   //  fPrintSizeX = -1;
659   //  fPrintSizeY = -1;                           600   //  fPrintSizeY = -1;
660                                                   601 
661   return true;                                    602   return true;
662 }                                                 603 }
663                                                   604 
664 /** Return if gl2ps is currently writing       << 
665  */                                            << 
666 bool G4OpenGLViewer::isGl2psWriting() {        << 
667                                                << 
668   if (!fGL2PSAction) return false;             << 
669   if (fGL2PSAction->fileWritingEnabled()) {    << 
670     return true;                               << 
671   }                                            << 
672   return false;                                << 
673 }                                              << 
674                                                << 
675                                                << 
676 G4bool G4OpenGLViewer::isFramebufferReady() {  << 
677   bool check = false;                          << 
678 #ifdef G4VIS_BUILD_OPENGLQT_DRIVER             << 
679   check = true;                                << 
680 #endif                                         << 
681 #ifdef G4VIS_BUILD_OPENGLX_DRIVER              << 
682   check = false;                               << 
683 #endif                                         << 
684 #ifdef G4VIS_BUILD_OPENGLXM_DRIVER             << 
685   check = false;                               << 
686 #endif                                         << 
687 #ifdef G4VIS_BUILD_OPENGLWIN32_DRIVER          << 
688   check = false;                               << 
689 #endif                                         << 
690                                                << 
691 #if GL_ARB_framebuffer_object                  << 
692   if (check) {                                 << 
693 //    if ( glCheckFramebufferStatus(GL_FRAMEBU << 
694 //      return false;                          << 
695 //    }                                        << 
696   }                                            << 
697 #endif                                         << 
698     return true;                               << 
699 }                                              << 
700                                                << 
701                                                << 
702 /* Draw Gl2Ps text if needed                   << 
703  */                                            << 
704 void G4OpenGLViewer::DrawText(const G4Text& g4 << 
705 {                                              << 
706   // gl2ps or GL window ?                      << 
707   if (isGl2psWriting()) {                      << 
708                                                << 
709     G4VSceneHandler::MarkerSizeType sizeType;  << 
710     G4double size = fSceneHandler.GetMarkerSiz << 
711     G4Point3D position = g4text.GetPosition(); << 
712                                                << 
713     G4String textString = g4text.GetText();    << 
714                                                << 
715     glRasterPos3d(position.x(),position.y(),po << 
716     GLint align = GL2PS_TEXT_B;                << 
717                                                << 
718     switch (g4text.GetLayout()) {              << 
719     case G4Text::left: align = GL2PS_TEXT_BL;  << 
720     case G4Text::centre: align = GL2PS_TEXT_B; << 
721     case G4Text::right: align = GL2PS_TEXT_BR; << 
722     }                                          << 
723                                                << 
724     fGL2PSAction->addTextOpt(textString.c_str( << 
725                                                << 
726   } else {                                     << 
727                                                << 
728     static G4int callCount = 0;                << 
729     ++callCount;                               << 
730     //if (callCount <= 10 || callCount%100 ==  << 
731     if (callCount <= 1) {                      << 
732       G4cout <<                                << 
733   "G4OpenGLViewer::DrawText: Not implemented f << 
734        << fName <<                             << 
735   "\"\n  Called with "                         << 
736        << g4text                               << 
737        << G4endl;                              << 
738     }                                          << 
739   }                                            << 
740 }                                              << 
741                                                << 
742 /** Change PointSize on gl2ps if needed        << 
743  */                                            << 
744 void G4OpenGLViewer::ChangePointSize(G4double  << 
745                                                << 
746   if (isGl2psWriting()) {                      << 
747     fGL2PSAction->setPointSize(int(size));     << 
748   } else {                                     << 
749     glPointSize (size);                        << 
750   }                                            << 
751 }                                              << 
752                                                << 
753                                                << 
754 /** Change LineSize on gl2ps if needed         << 
755  */                                            << 
756 void G4OpenGLViewer::ChangeLineWidth(G4double  << 
757                                                << 
758   if (isGl2psWriting()) {                      << 
759     fGL2PSAction->setLineWidth(int(width));    << 
760   } else {                                     << 
761     glLineWidth (width);                       << 
762   }                                            << 
763 }                                              << 
764                                                << 
765 /**                                            << 
766  Export image with the given name with width a << 
767  Several cases :                               << 
768  If name is "", filename will have the default << 
769  If name is "toto.png", set the name to "toto" << 
770  If name is "toto", set the name to "toto" and << 
771    Will also add an incremented suffix at the  << 
772 */                                             << 
773 bool G4OpenGLViewer::exportImage(std::string n << 
774                                                << 
775   if (! setExportFilename(name)) {             << 
776     return false;                              << 
777   }                                            << 
778                                                << 
779   if ((width != -1) && (height != -1)) {       << 
780     setExportSize(width, height);              << 
781   }                                            << 
782                                                << 
783   if (fExportImageFormat == "eps") {           << 
784     fGL2PSAction->setExportImageFormat_EPS();  << 
785   } else if (fExportImageFormat == "ps") {     << 
786     fGL2PSAction->setExportImageFormat_PS();   << 
787   } else if (fExportImageFormat == "svg") {    << 
788     fGL2PSAction->setExportImageFormat_SVG();  << 
789   } else if (fExportImageFormat == "pdf") {    << 
790     fGL2PSAction->setExportImageFormat_PDF();  << 
791   } else {                                     << 
792     setExportImageFormat(fExportImageFormat,tr << 
793     return false;                              << 
794   }                                            << 
795                                                << 
796   bool res;                                    << 
797                                                << 
798   // Change the LC_NUMERIC value in order to h << 
799   // This case is only useful for French, Cana << 
800   size_t len = strlen(setlocale(LC_NUMERIC,NUL << 
801   char* oldLocale = (char*)(malloc(len+1));    << 
802   if(oldLocale!=NULL) strncpy(oldLocale,setloc << 
803   setlocale(LC_NUMERIC,"C");                   << 
804                                                << 
805   if (((fExportImageFormat == "eps") || (fExpo << 
806     res = printNonVectoredEPS();               << 
807   } else {                                     << 
808     res = printVectoredEPS();                  << 
809   }                                            << 
810                                                << 
811   // restore the local                         << 
812   if (oldLocale) {                             << 
813     setlocale(LC_NUMERIC,oldLocale);           << 
814     free(oldLocale);                           << 
815   }                                            << 
816                                                << 
817   if (res == false) {                          << 
818     G4cerr << "Error saving file... " << getRe << 
819   } else {                                     << 
820     G4cout << "File " << getRealPrintFilename( << 
821                                                << 
822     // increment index if necessary            << 
823     if ( fExportFilenameIndex != -1) {         << 
824       fExportFilenameIndex++;                  << 
825     }                                          << 
826   }                                            << 
827                                                << 
828   return res;                                  << 
829 }                                              << 
830                                                << 
831                                                   605 
832 bool G4OpenGLViewer::printGl2PS() {               606 bool G4OpenGLViewer::printGl2PS() {
833                                                   607 
834   int width = getRealExportWidth();            << 608   int width = getRealPrintSizeX();
835   int height = getRealExportHeight();          << 609   int height = getRealPrintSizeY();
836   bool res = true;                             << 
837                                                << 
838   // no need to redraw at each new primitive f << 
839   G4OpenGLSceneHandler& oglSceneHandler = dyna << 
840   G4OpenGLSceneHandler::FlushAction originalFl << 
841   oglSceneHandler.SetFlushAction(G4OpenGLScene << 
842                                                   610 
843   if (!fGL2PSAction) return false;                611   if (!fGL2PSAction) return false;
844                                                   612 
845   fGL2PSAction->setFileName(getRealPrintFilena    613   fGL2PSAction->setFileName(getRealPrintFilename().c_str());
846   // try to resize                                614   // try to resize
847   int X = fWinSize_x;                             615   int X = fWinSize_x;
848   int Y = fWinSize_y;                             616   int Y = fWinSize_y;
849                                                   617 
850   fWinSize_x = width;                             618   fWinSize_x = width;
851   fWinSize_y = height;                            619   fWinSize_y = height;
852   // Laurent G. 16/03/10 : Not the good way to    620   // Laurent G. 16/03/10 : Not the good way to do. 
853   // We should draw in a new offscreen context    621   // We should draw in a new offscreen context instead of
854   // resizing and drawing in current window...    622   // resizing and drawing in current window...
855   // This should be solve when we will do an o    623   // This should be solve when we will do an offscreen method
856   // to render OpenGL                             624   // to render OpenGL
857   // See :                                        625   // See : 
858   // http://developer.apple.com/Mac/library/do    626   // http://developer.apple.com/Mac/library/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_offscreen/opengl_offscreen.html
859   // http://www.songho.ca/opengl/gl_fbo.html      627   // http://www.songho.ca/opengl/gl_fbo.html
860                                                   628 
861    ResizeGLView();                             << 629   ResizeGLView();
862    bool extendBuffer = true;                   << 630   if (fGL2PSAction->enableFileWriting()) {
863    bool endWriteAction = false;                << 631 
864    bool beginWriteAction = true;               << 632     // Set the viewport
865    bool filePointerOk = true;                  << 633     //    fGL2PSAction->setViewport(0, 0, getRealPrintSizeX(),getRealPrintSizeY());  
866    while ((extendBuffer) && (! endWriteAction) << 634     // By default, we choose the line width (trajectories...)
867                                                << 635     fGL2PSAction->setLineWidth(1);
868      beginWriteAction = fGL2PSAction->enableFi << 636     // By default, we choose the point size (markers...)
869      if(beginWriteAction) {                    << 637     fGL2PSAction->setPointSize(2);
870        GLint vp[4];                            << 638 
871        ::glGetIntegerv(GL_VIEWPORT,vp);        << 639     DrawView ();
872        fGL2PSAction->setViewport(vp[0],vp[1],v << 640     fGL2PSAction->disableFileWriting();
873        beginWriteAction = fGL2PSAction->beginP << 641   }
874      }                                         << 642 
875                                                << 
876      // 3 cases :                              << 
877      // - true                                 << 
878      // - false && ! fGL2PSAction->fileWriting << 
879      // - false && fGL2PSAction->fileWritingEn << 
880                                                << 
881      filePointerOk = fGL2PSAction->fileWriting << 
882                                                << 
883      if (beginWriteAction) {                   << 
884                                                << 
885        // Set the viewport                     << 
886        // By default, we choose the line width << 
887        fGL2PSAction->setLineWidth(fGl2psDefaul << 
888        // By default, we choose the point size << 
889        fGL2PSAction->setPointSize(fGl2psDefaul << 
890                                                << 
891        DrawView ();                            << 
892                                                << 
893        endWriteAction = fGL2PSAction->endPage( << 
894        fGL2PSAction->disableFileWriting();     << 
895      }                                         << 
896      if (filePointerOk) {                      << 
897        if ((! endWriteAction) || (! beginWrite << 
898          extendBuffer = fGL2PSAction->extendBu << 
899        }                                       << 
900      }                                         << 
901    }                                           << 
902    fGL2PSAction->resetBufferSizeParameters();  << 
903                                                << 
904    if (!extendBuffer ) {                       << 
905      G4cerr << "ERROR: gl2ps buffer size is no << 
906      res = false;                              << 
907    }                                           << 
908    if (!beginWriteAction ) {                   << 
909      G4cerr << "ERROR: saving file "<<getRealP << 
910      res = false;                              << 
911    }                                           << 
912    if (!endWriteAction ) {                     << 
913      G4cerr << "gl2ps error. No output produce << 
914      res = false;                              << 
915    }                                           << 
916   fWinSize_x = X;                                 643   fWinSize_x = X;
917   fWinSize_y = Y;                                 644   fWinSize_y = Y;
918                                                << 645   ResizeGLView();
919   oglSceneHandler.SetFlushAction(originalFlush << 646   DrawView ();
920                                                   647 
921   // Reset for next time (useful is size chang    648   // Reset for next time (useful is size change)
922   //  fPrintSizeX = 0;                            649   //  fPrintSizeX = 0;
923   //  fPrintSizeY = 0;                            650   //  fPrintSizeY = 0;
924                                                   651 
925   return res;                                  << 652   return true;
926 }                                                 653 }
927                                                   654 
928 unsigned int G4OpenGLViewer::getWinWidth() con << 655 unsigned int G4OpenGLViewer::getWinWidth() {
929   return fWinSize_x;                              656   return fWinSize_x;
930 }                                                 657 }
931                                                   658 
932 unsigned int G4OpenGLViewer::getWinHeight() co << 659 unsigned int G4OpenGLViewer::getWinHeight() {
933   return fWinSize_y;                              660   return fWinSize_y;
934 }                                                 661 }
935                                                   662 
936 G4bool G4OpenGLViewer::sizeHasChanged() {         663 G4bool G4OpenGLViewer::sizeHasChanged() {
937   return fSizeHasChanged;                         664   return fSizeHasChanged;
938 }                                                 665 }
939                                                   666 
940 G4int G4OpenGLViewer::getRealExportWidth() {   << 667 G4int G4OpenGLViewer::getRealPrintSizeX() {
941   if (fPrintSizeX == -1) {                        668   if (fPrintSizeX == -1) {
942     return fWinSize_x;                            669     return fWinSize_x;
943   }                                               670   }
944   GLint dims[2];                                  671   GLint dims[2];
945   glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);      672   glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
946                                                   673 
947   // L.Garnier 01-2010: Some problems with mac    674   // L.Garnier 01-2010: Some problems with mac 10.6
948   if ((dims[0] !=0 ) && (dims[1] !=0)) {          675   if ((dims[0] !=0 ) && (dims[1] !=0)) {
949     if (fPrintSizeX > dims[0]){                   676     if (fPrintSizeX > dims[0]){
950       return dims[0];                             677       return dims[0];
951     }                                             678     }
952   }                                               679   }
953   if (fPrintSizeX < -1){                          680   if (fPrintSizeX < -1){
954     return 0;                                     681     return 0;
955   }                                               682   }
956   return fPrintSizeX;                             683   return fPrintSizeX;
957 }                                                 684 }
958                                                   685 
959 G4int G4OpenGLViewer::getRealExportHeight() {  << 686 G4int G4OpenGLViewer::getRealPrintSizeY() {
960   if (fPrintSizeY == -1) {                        687   if (fPrintSizeY == -1) {
961     return fWinSize_y;                            688     return fWinSize_y;
962   }                                               689   }
963   GLint dims[2];                                  690   GLint dims[2];
964   glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);      691   glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
965                                                   692 
966   // L.Garnier 01-2010: Some problems with mac    693   // L.Garnier 01-2010: Some problems with mac 10.6
967   if ((dims[0] !=0 ) && (dims[1] !=0)) {          694   if ((dims[0] !=0 ) && (dims[1] !=0)) {
968     if (fPrintSizeY > dims[1]){                   695     if (fPrintSizeY > dims[1]){
969       return dims[1];                             696       return dims[1];
970     }                                             697     }
971   }                                               698   }
972   if (fPrintSizeY < -1){                          699   if (fPrintSizeY < -1){
973     return 0;                                     700     return 0;
974   }                                               701   }
975   return fPrintSizeY;                             702   return fPrintSizeY;
976 }                                                 703 }
977                                                   704 
978 void G4OpenGLViewer::setExportSize(G4int X, G4 << 705 void G4OpenGLViewer::setPrintSize(G4int X, G4int Y) {
979   fPrintSizeX = X;                                706   fPrintSizeX = X;
980   fPrintSizeY = Y;                                707   fPrintSizeY = Y;
981 }                                                 708 }
982                                                   709 
983 /**                                            << 710 void G4OpenGLViewer::setPrintFilename(G4String name,G4bool inc) {
984  If name is "" or "!", filename and extension  << 711   if (name != "") {
985  If name is "toto.png", set the name to "toto" << 712     fPrintFilename = name;
986  If name is "toto", set the name to "toto" and << 
987  If name is the same as previous, do not reset << 
988 */                                             << 
989 bool G4OpenGLViewer::setExportFilename(G4Strin << 
990   if (name == "!") {                           << 
991     name = "";                                 << 
992   }                                            << 
993                                                << 
994   if (inc) {                                   << 
995     if ((name != "") && (fExportFilename != na << 
996       fExportFilenameIndex=0;                  << 
997     }                                          << 
998   } else {                                        713   } else {
999     fExportFilenameIndex=-1;                   << 714     fPrintFilename = "G4OpenGL";  // by default
1000   }                                              715   }
1001                                               << 716   if (inc) {
1002   if (name.size() == 0) {                     << 717     fPrintFilenameIndex=0;
1003     name = getRealPrintFilename().c_str();    << 
1004   } else {                                       718   } else {
1005     // guess format by extention              << 719     fPrintFilenameIndex=-1;
1006     std::string extension = name.substr(name. << 
1007     // If there is a dot in the name the abov << 
1008     if (extension.size() >= 3 && extension.si << 
1009       if (setExportImageFormat(extension, fal << 
1010         fExportFilename = name.substr(0,name. << 
1011       } else {  // No viable extension found  << 
1012         return false;                         << 
1013       }                                       << 
1014     } else {  // Assume name is already the r << 
1015         fExportFilename = name;               << 
1016     }                                         << 
1017   }                                              720   }
1018   return true;                                << 
1019 }                                                721 }
1020                                                  722 
1021 std::string G4OpenGLViewer::getRealPrintFilen    723 std::string G4OpenGLViewer::getRealPrintFilename() {
1022   std::string temp = fExportFilename;         << 724   std::string temp = fPrintFilename;
1023   if (fExportFilenameIndex != -1) {           << 725   if (fPrintFilenameIndex != -1) {
1024     temp += std::string("_");                    726     temp += std::string("_");
1025     std::ostringstream os;                       727     std::ostringstream os;
1026     os << std::setw(4) << std::setfill('0') < << 728     os << fPrintFilenameIndex;
1027     std::string nb_str = os.str();               729     std::string nb_str = os.str();
1028     temp += nb_str;                              730     temp += nb_str;
1029   }                                              731   }
1030   temp += "."+fExportImageFormat;             << 732   temp += ".eps";
1031   return temp;                                   733   return temp;
1032 }                                                734 }
1033                                                  735 
1034 GLdouble G4OpenGLViewer::getSceneNearWidth()     736 GLdouble G4OpenGLViewer::getSceneNearWidth()
1035 {                                                737 {
1036   if (!fSceneHandler.GetScene()) {               738   if (!fSceneHandler.GetScene()) {
1037     return 0;                                    739     return 0;
1038   }                                              740   }
1039   const G4Point3D targetPoint                    741   const G4Point3D targetPoint
1040     = fSceneHandler.GetScene()->GetStandardTa    742     = fSceneHandler.GetScene()->GetStandardTargetPoint()
1041     + fVP.GetCurrentTargetPoint ();              743     + fVP.GetCurrentTargetPoint ();
1042   G4double radius = fSceneHandler.GetScene()-    744   G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
1043   if(radius<=0.) radius = 1.;                    745   if(radius<=0.) radius = 1.;
1044   const G4double cameraDistance = fVP.GetCame    746   const G4double cameraDistance = fVP.GetCameraDistance (radius);
1045   const GLdouble pnear   = fVP.GetNearDistanc    747   const GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
1046   return 2 * fVP.GetFrontHalfHeight (pnear, r    748   return 2 * fVP.GetFrontHalfHeight (pnear, radius);
1047 }                                                749 }
1048                                                  750 
1049 GLdouble G4OpenGLViewer::getSceneFarWidth()      751 GLdouble G4OpenGLViewer::getSceneFarWidth()
1050 {                                                752 {
1051   if (!fSceneHandler.GetScene()) {               753   if (!fSceneHandler.GetScene()) {
1052     return 0;                                    754     return 0;
1053   }                                              755   }
1054   const G4Point3D targetPoint                    756   const G4Point3D targetPoint
1055     = fSceneHandler.GetScene()->GetStandardTa    757     = fSceneHandler.GetScene()->GetStandardTargetPoint()
1056     + fVP.GetCurrentTargetPoint ();              758     + fVP.GetCurrentTargetPoint ();
1057   G4double radius = fSceneHandler.GetScene()-    759   G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
1058   if(radius<=0.) radius = 1.;                    760   if(radius<=0.) radius = 1.;
1059   const G4double cameraDistance = fVP.GetCame    761   const G4double cameraDistance = fVP.GetCameraDistance (radius);
1060   const GLdouble pnear   = fVP.GetNearDistanc    762   const GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
1061   const GLdouble pfar    = fVP.GetFarDistance    763   const GLdouble pfar    = fVP.GetFarDistance  (cameraDistance, pnear, radius);
1062   return 2 * fVP.GetFrontHalfHeight (pfar, ra    764   return 2 * fVP.GetFrontHalfHeight (pfar, radius);
1063 }                                                765 }
1064                                                  766 
1065                                                  767 
1066 GLdouble G4OpenGLViewer::getSceneDepth()         768 GLdouble G4OpenGLViewer::getSceneDepth()
1067 {                                                769 {
1068   if (!fSceneHandler.GetScene()) {               770   if (!fSceneHandler.GetScene()) {
1069     return 0;                                    771     return 0;
1070   }                                              772   }
1071   const G4Point3D targetPoint                    773   const G4Point3D targetPoint
1072     = fSceneHandler.GetScene()->GetStandardTa    774     = fSceneHandler.GetScene()->GetStandardTargetPoint()
1073     + fVP.GetCurrentTargetPoint ();              775     + fVP.GetCurrentTargetPoint ();
1074   G4double radius = fSceneHandler.GetScene()-    776   G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
1075   if(radius<=0.) radius = 1.;                    777   if(radius<=0.) radius = 1.;
1076   const G4double cameraDistance = fVP.GetCame    778   const G4double cameraDistance = fVP.GetCameraDistance (radius);
1077   const GLdouble pnear   = fVP.GetNearDistanc    779   const GLdouble pnear   = fVP.GetNearDistance (cameraDistance, radius);
1078   return fVP.GetFarDistance  (cameraDistance,    780   return fVP.GetFarDistance  (cameraDistance, pnear, radius)- pnear;
1079 }                                                781 }
1080                                                  782 
1081                                                  783 
1082                                                  784 
1083 void G4OpenGLViewer::rotateScene(G4double dx, << 785 void G4OpenGLViewer::rotateScene(G4double dx, G4double dy,G4double deltaRotation)
1084 {                                             << 
1085   if (fVP.GetRotationStyle() == G4ViewParamet << 
1086     rotateSceneInViewDirection(dx,dy);        << 
1087   } else {                                    << 
1088     if( dx != 0) {                            << 
1089       rotateSceneThetaPhi(dx,0);              << 
1090     }                                         << 
1091     if( dy != 0) {                            << 
1092       rotateSceneThetaPhi(0,dy);              << 
1093     }                                         << 
1094   }                                           << 
1095 }                                             << 
1096                                               << 
1097                                               << 
1098 void G4OpenGLViewer::rotateSceneToggle(G4doub << 
1099 {                                             << 
1100   if (fVP.GetRotationStyle() != G4ViewParamet << 
1101     rotateSceneInViewDirection(dx,dy);        << 
1102   } else {                                    << 
1103     if( dx != 0) {                            << 
1104       rotateSceneThetaPhi(dx,0);              << 
1105     }                                         << 
1106     if( dy != 0) {                            << 
1107       rotateSceneThetaPhi(0,dy);              << 
1108     }                                         << 
1109   }                                           << 
1110 }                                             << 
1111                                               << 
1112 void G4OpenGLViewer::rotateSceneThetaPhi(G4do << 
1113 {                                                786 {
1114   if (!fSceneHandler.GetScene()) {               787   if (!fSceneHandler.GetScene()) {
1115     return;                                      788     return;
1116   }                                              789   }
1117                                                  790 
1118   G4Vector3D vp;                                 791   G4Vector3D vp;
1119   G4Vector3D up;                                 792   G4Vector3D up;
1120                                                  793   
1121   G4Vector3D xprime;                             794   G4Vector3D xprime;
1122   G4Vector3D yprime;                             795   G4Vector3D yprime;
1123   G4Vector3D zprime;                             796   G4Vector3D zprime;
1124                                                  797   
1125   G4double delta_alpha;                          798   G4double delta_alpha;
1126   G4double delta_theta;                          799   G4double delta_theta;
1127                                                  800   
1128   G4Vector3D new_vp;                             801   G4Vector3D new_vp;
1129   G4Vector3D new_up;                             802   G4Vector3D new_up;
1130                                                  803   
1131   G4double cosalpha;                             804   G4double cosalpha;
1132   G4double sinalpha;                             805   G4double sinalpha;
1133                                                  806   
1134   G4Vector3D a1;                                 807   G4Vector3D a1;
1135   G4Vector3D a2;                                 808   G4Vector3D a2;
1136   G4Vector3D delta;                              809   G4Vector3D delta;
1137   G4Vector3D viewPoint;                          810   G4Vector3D viewPoint;
1138                                                  811 
1139                                                  812     
1140   //phi spin stuff here                          813   //phi spin stuff here
1141                                                  814   
1142   vp = fVP.GetViewpointDirection ().unit ();     815   vp = fVP.GetViewpointDirection ().unit ();
1143   up = fVP.GetUpVector ().unit ();               816   up = fVP.GetUpVector ().unit ();
1144                                                  817   
1145   yprime = (up.cross(vp)).unit();                818   yprime = (up.cross(vp)).unit();
1146   zprime = (vp.cross(yprime)).unit();            819   zprime = (vp.cross(yprime)).unit();
1147                                                  820   
1148   if (fVP.GetLightsMoveWithCamera()) {           821   if (fVP.GetLightsMoveWithCamera()) {
1149     delta_alpha = dy * fRot_sens;             << 822     delta_alpha = dy * deltaRotation;
1150     delta_theta = -dx * fRot_sens;            << 823     delta_theta = -dx * deltaRotation;
1151   } else {                                       824   } else {
1152     delta_alpha = -dy * fRot_sens;            << 825     delta_alpha = -dy * deltaRotation;
1153     delta_theta = dx * fRot_sens;             << 826     delta_theta = dx * deltaRotation;
1154   }                                              827   }    
1155                                                  828   
1156   delta_alpha *= CLHEP::deg;                  << 829   delta_alpha *= deg;
1157   delta_theta *= CLHEP::deg;                  << 830   delta_theta *= deg;
1158                                                  831   
1159   new_vp = std::cos(delta_alpha) * vp + std::    832   new_vp = std::cos(delta_alpha) * vp + std::sin(delta_alpha) * zprime;
1160                                                  833   
1161   // to avoid z rotation flipping                834   // to avoid z rotation flipping
1162   // to allow more than 360° rotation        << 835   // to allow more than 360° rotation
1163                                                  836 
1164   if (fVP.GetLightsMoveWithCamera()) {           837   if (fVP.GetLightsMoveWithCamera()) {
1165     new_up = (new_vp.cross(yprime)).unit();      838     new_up = (new_vp.cross(yprime)).unit();
1166     if (new_vp.z()*vp.z() <0) {                  839     if (new_vp.z()*vp.z() <0) {
1167       new_up.set(new_up.x(),-new_up.y(),new_u    840       new_up.set(new_up.x(),-new_up.y(),new_up.z());
1168     }                                            841     }
1169   } else {                                       842   } else {
1170     new_up = up;                                 843     new_up = up;
1171     if (new_vp.z()*vp.z() <0) {                  844     if (new_vp.z()*vp.z() <0) {
1172       new_up.set(new_up.x(),-new_up.y(),new_u    845       new_up.set(new_up.x(),-new_up.y(),new_up.z());
1173     }                                            846     }
1174   }                                              847   }
1175   fVP.SetUpVector(new_up);                       848   fVP.SetUpVector(new_up);
1176   ////////////////                               849   ////////////////
1177   // Rotates by fixed azimuthal angle delta_t    850   // Rotates by fixed azimuthal angle delta_theta.
1178                                                  851   
1179   cosalpha = new_up.dot (new_vp.unit());         852   cosalpha = new_up.dot (new_vp.unit());
1180   sinalpha = std::sqrt (1. - std::pow (cosalp    853   sinalpha = std::sqrt (1. - std::pow (cosalpha, 2));
1181   yprime = (new_up.cross (new_vp.unit())).uni    854   yprime = (new_up.cross (new_vp.unit())).unit ();
1182   xprime = yprime.cross (new_up);                855   xprime = yprime.cross (new_up);
1183   // Projection of vp on plane perpendicular     856   // Projection of vp on plane perpendicular to up...
1184   a1 = sinalpha * xprime;                        857   a1 = sinalpha * xprime;
1185   // Required new projection...                  858   // Required new projection...
1186   a2 = sinalpha * (std::cos (delta_theta) * x    859   a2 = sinalpha * (std::cos (delta_theta) * xprime + std::sin (delta_theta) * yprime);
1187   // Required Increment vector...                860   // Required Increment vector...
1188   delta = a2 - a1;                               861   delta = a2 - a1;
1189   // So new viewpoint is...                      862   // So new viewpoint is...
1190   viewPoint = new_vp.unit() + delta;             863   viewPoint = new_vp.unit() + delta;
1191                                                  864   
1192   fVP.SetViewAndLights (viewPoint);              865   fVP.SetViewAndLights (viewPoint);
1193 }                                                866 }
1194                                                  867 
1195                                                  868 
1196 void G4OpenGLViewer::rotateSceneInViewDirecti << 869 void G4OpenGLViewer::rotateSceneInViewDirection(G4double dx, G4double dy,G4double deltaRotation)
1197 {                                                870 {
1198   if (!fSceneHandler.GetScene()) {               871   if (!fSceneHandler.GetScene()) {
1199     return;                                      872     return;
1200   }                                              873   }
1201                                                  874 
1202   G4Vector3D vp;                                 875   G4Vector3D vp;
1203   G4Vector3D up;                                 876   G4Vector3D up;
1204                                                  877   
1205   G4Vector3D xprime;                             878   G4Vector3D xprime;
1206   G4Vector3D yprime;                             879   G4Vector3D yprime;
1207   G4Vector3D zprime;                             880   G4Vector3D zprime;
1208                                                  881   
1209   G4Vector3D new_vp;                             882   G4Vector3D new_vp;
1210   G4Vector3D new_up;                             883   G4Vector3D new_up;
1211                                                  884   
1212   G4Vector3D a1;                                 885   G4Vector3D a1;
1213   G4Vector3D a2;                                 886   G4Vector3D a2;
1214   G4Vector3D delta;                              887   G4Vector3D delta;
1215   G4Vector3D viewPoint;                          888   G4Vector3D viewPoint;
1216                                                  889 
1217   dx = dx/100;                                << 890     
1218   dy = dy/100;                                << 
1219                                               << 
1220   //phi spin stuff here                          891   //phi spin stuff here
1221                                                  892   
                                                   >> 893 #ifdef G4DEBUG_VIS_OGL
                                                   >> 894   printf("G4OpenGLViewer::rotateScene dx:%f dy:%f delta:%f\n",dx,dy, deltaRotation);
                                                   >> 895 #endif
                                                   >> 896 
1222   vp = fVP.GetViewpointDirection ().unit();      897   vp = fVP.GetViewpointDirection ().unit();
1223   up = fVP.GetUpVector ().unit();                898   up = fVP.GetUpVector ().unit();
1224                                                  899 
1225   G4Vector3D zPrimeVector = G4Vector3D(up.y()    900   G4Vector3D zPrimeVector = G4Vector3D(up.y()*vp.z()-up.z()*vp.y(),
1226                              up.z()*vp.x()-up    901                              up.z()*vp.x()-up.x()*vp.z(),
1227                              up.x()*vp.y()-up    902                              up.x()*vp.y()-up.y()*vp.x());
1228                                                  903 
1229   viewPoint = vp/fRot_sens + (zPrimeVector*dx << 904   viewPoint = vp/deltaRotation + (zPrimeVector*dx - up*dy) ;
1230   new_up = G4Vector3D(viewPoint.y()*zPrimeVec    905   new_up = G4Vector3D(viewPoint.y()*zPrimeVector.z()-viewPoint.z()*zPrimeVector.y(),
1231                        viewPoint.z()*zPrimeVe    906                        viewPoint.z()*zPrimeVector.x()-viewPoint.x()*zPrimeVector.z(),
1232                        viewPoint.x()*zPrimeVe    907                        viewPoint.x()*zPrimeVector.y()-viewPoint.y()*zPrimeVector.x());
1233                                                  908 
1234   G4Vector3D new_upUnit = new_up.unit();         909   G4Vector3D new_upUnit = new_up.unit();
1235                                                  910   
1236                                                  911   
1237                                                  912 
1238    fVP.SetUpVector(new_upUnit);                  913    fVP.SetUpVector(new_upUnit);
1239    fVP.SetViewAndLights (viewPoint);             914    fVP.SetViewAndLights (viewPoint);
1240 }                                                915 }
1241                                                  916 
1242                                               << 917 #endif
1243 void G4OpenGLViewer::addExportImageFormat(std << 
1244   fExportImageFormatVector.push_back(format); << 
1245 }                                             << 
1246                                               << 
1247 bool G4OpenGLViewer::setExportImageFormat(std << 
1248   bool found = false;                         << 
1249   std::string list;                           << 
1250   for (unsigned int a=0; a<fExportImageFormat << 
1251     list +=fExportImageFormatVector.at(a) + " << 
1252                                               << 
1253     if (fExportImageFormatVector.at(a) == for << 
1254       if (! quiet) {                          << 
1255         G4cout << " Changing export format to << 
1256       }                                       << 
1257       if (format != fExportImageFormat) {     << 
1258         fExportFilenameIndex = 0;             << 
1259         fExportImageFormat = format;          << 
1260       }                                       << 
1261       return true;                            << 
1262     }                                         << 
1263   }                                           << 
1264   if (! found) {                              << 
1265     if (format.size() == 0) {                 << 
1266       G4cout << " Current formats availables  << 
1267     } else {                                  << 
1268       G4cerr << " Format \"" << format << "\" << 
1269     }                                         << 
1270   }                                           << 
1271   return false;                               << 
1272 }                                             << 
1273                                               << 
1274                                               << 
1275 // From MESA implementation :                 << 
1276 // http://www.techques.com/question/1-8660454 << 
1277                                               << 
1278 void G4OpenGLViewer::g4GluPickMatrix(GLdouble << 
1279                      GLint viewport[4])       << 
1280   {                                           << 
1281     GLdouble mat[16];                         << 
1282     GLdouble sx, sy;                          << 
1283     GLdouble tx, ty;                          << 
1284                                               << 
1285     sx = viewport[2] / width;                 << 
1286     sy = viewport[3] / height;                << 
1287     tx = (viewport[2] + 2.0 * (viewport[0] -  << 
1288     ty = (viewport[3] + 2.0 * (viewport[1] -  << 
1289                                               << 
1290 #define M(row, col) mat[col*4+row]            << 
1291     M(0, 0) = sx;                             << 
1292     M(0, 1) = 0.0;                            << 
1293     M(0, 2) = 0.0;                            << 
1294     M(0, 3) = tx;                             << 
1295     M(1, 0) = 0.0;                            << 
1296     M(1, 1) = sy;                             << 
1297     M(1, 2) = 0.0;                            << 
1298     M(1, 3) = ty;                             << 
1299     M(2, 0) = 0.0;                            << 
1300     M(2, 1) = 0.0;                            << 
1301     M(2, 2) = 1.0;                            << 
1302     M(2, 3) = 0.0;                            << 
1303     M(3, 0) = 0.0;                            << 
1304     M(3, 1) = 0.0;                            << 
1305     M(3, 2) = 0.0;                            << 
1306     M(3, 3) = 1.0;                            << 
1307 #undef M                                      << 
1308                                               << 
1309     glMultMatrixd(mat);                       << 
1310 }                                             << 
1311                                               << 
1312                                               << 
1313                                               << 
1314                                               << 
1315                                               << 
1316 // From MESA implementation :                 << 
1317 // https://github.com/jlamarche/iOS-OpenGLES- << 
1318 // or http://www.daniweb.com/software-develop << 
1319                                               << 
1320 void G4OpenGLViewer::g4GluLookAt( GLdouble ey << 
1321                         GLdouble centerx, GLd << 
1322                         centerz,              << 
1323                         GLdouble upx, GLdoubl << 
1324 {                                             << 
1325   GLdouble mat[16];                           << 
1326   GLdouble x[3], y[3], z[3];                  << 
1327   GLdouble mag;                               << 
1328                                               << 
1329   /* Make rotation matrix */                  << 
1330                                               << 
1331   /* Z vector */                              << 
1332   z[0] = eyex - centerx;                      << 
1333   z[1] = eyey - centery;                      << 
1334   z[2] = eyez - centerz;                      << 
1335   mag = std::sqrt(z[0] * z[0] + z[1] * z[1] + << 
1336   if (mag) {      /* mpichler, 19950515 */    << 
1337     z[0] /= mag;                              << 
1338     z[1] /= mag;                              << 
1339     z[2] /= mag;                              << 
1340   }                                           << 
1341                                               << 
1342   /* Y vector */                              << 
1343   y[0] = upx;                                 << 
1344   y[1] = upy;                                 << 
1345   y[2] = upz;                                 << 
1346                                               << 
1347   /* X vector = Y cross Z */                  << 
1348   x[0] = y[1] * z[2] - y[2] * z[1];           << 
1349   x[1] = -y[0] * z[2] + y[2] * z[0];          << 
1350   x[2] = y[0] * z[1] - y[1] * z[0];           << 
1351                                               << 
1352   /* Recompute Y = Z cross X */               << 
1353   y[0] = z[1] * x[2] - z[2] * x[1];           << 
1354   y[1] = -z[0] * x[2] + z[2] * x[0];          << 
1355   y[2] = z[0] * x[1] - z[1] * x[0];           << 
1356                                               << 
1357   /* mpichler, 19950515 */                    << 
1358   /* cross product gives area of parallelogra << 
1359    * non-perpendicular unit-length vectors; s << 
1360    */                                         << 
1361                                               << 
1362   mag = std::sqrt(x[0] * x[0] + x[1] * x[1] + << 
1363   if (mag) {                                  << 
1364     x[0] /= mag;                              << 
1365     x[1] /= mag;                              << 
1366     x[2] /= mag;                              << 
1367   }                                           << 
1368                                               << 
1369   mag = std::sqrt(y[0] * y[0] + y[1] * y[1] + << 
1370   if (mag) {                                  << 
1371     y[0] /= mag;                              << 
1372     y[1] /= mag;                              << 
1373     y[2] /= mag;                              << 
1374   }                                           << 
1375                                               << 
1376 #define M(row,col)  mat[col*4+row]            << 
1377   M(0, 0) = x[0];                             << 
1378   M(0, 1) = x[1];                             << 
1379   M(0, 2) = x[2];                             << 
1380   M(0, 3) = 0.0;                              << 
1381   M(1, 0) = y[0];                             << 
1382   M(1, 1) = y[1];                             << 
1383   M(1, 2) = y[2];                             << 
1384   M(1, 3) = 0.0;                              << 
1385   M(2, 0) = z[0];                             << 
1386   M(2, 1) = z[1];                             << 
1387   M(2, 2) = z[2];                             << 
1388   M(2, 3) = 0.0;                              << 
1389   M(3, 0) = 0.0;                              << 
1390   M(3, 1) = 0.0;                              << 
1391   M(3, 2) = 0.0;                              << 
1392   M(3, 3) = 1.0;                              << 
1393 #undef M                                      << 
1394   glMultMatrixd(mat);                         << 
1395                                               << 
1396   /* Translate Eye to Origin */               << 
1397   glTranslated(-eyex, -eyey, -eyez);          << 
1398 }                                             << 
1399                                               << 
1400 void G4OpenGLViewer::g4GlOrtho (GLdouble left << 
1401   //  glOrtho (left, right, bottom, top, near << 
1402                                               << 
1403   GLdouble a = 2.0 / (right - left);          << 
1404   GLdouble b = 2.0 / (top - bottom);          << 
1405   GLdouble c = -2.0 / (zFar - zNear);         << 
1406                                               << 
1407   GLdouble tx = - (right + left)/(right - lef << 
1408   GLdouble ty = - (top + bottom)/(top - botto << 
1409   GLdouble tz = - (zFar + zNear)/(zFar - zNea << 
1410                                               << 
1411   GLdouble ortho[16] = {                      << 
1412     a, 0, 0, 0,                               << 
1413     0, b, 0, 0,                               << 
1414     0, 0, c, 0,                               << 
1415     tx, ty, tz, 1                             << 
1416   };                                          << 
1417   glMultMatrixd(ortho);                       << 
1418                                               << 
1419 }                                             << 
1420                                               << 
1421                                               << 
1422 void G4OpenGLViewer::g4GlFrustum (GLdouble le << 
1423   //  glFrustum (left, right, bottom, top, ne << 
1424                                               << 
1425   GLdouble deltaX = right - left;             << 
1426   GLdouble deltaY = top - bottom;             << 
1427   GLdouble deltaZ = zFar - zNear;             << 
1428                                               << 
1429   GLdouble a = 2.0f * zNear / deltaX;         << 
1430   GLdouble b = 2.0f * zNear / deltaY;         << 
1431   GLdouble c = (right + left) / deltaX;       << 
1432   GLdouble d = (top + bottom) / deltaY;       << 
1433   GLdouble e = -(zFar + zNear) / (zFar - zNea << 
1434   GLdouble f = -2.0f * zFar * zNear / deltaZ; << 
1435                                               << 
1436   GLdouble proj[16] = {                       << 
1437     a, 0, 0, 0,                               << 
1438     0, b, 0, 0,                               << 
1439     c, d, e, -1.0f,                           << 
1440     0, 0, f, 0                                << 
1441   };                                          << 
1442                                               << 
1443   glMultMatrixd(proj);                        << 
1444                                               << 
1445 }                                             << 
1446                                               << 
1447 G4String G4OpenGLViewerPickMap::print() {     << 
1448   std::ostringstream txt;                     << 
1449   for (unsigned int a=0; a<fAttributes.size() << 
1450     txt << fAttributes[a];                    << 
1451     if (a < fAttributes.size() - 1) txt << "\ << 
1452   }                                           << 
1453   return txt.str();                           << 
1454 }                                             << 
1455                                                  918