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