source: trunk/source/visualization/OpenGL/src/G4OpenGLXViewer.cc@ 997

Last change on this file since 997 was 980, checked in by garnier, 17 years ago

passage de print OK
  • Property svn:mime-type set to text/cpp
File size: 23.5 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: G4OpenGLXViewer.cc,v 1.52 2009/04/08 16:55:44 lgarnier Exp $
28// GEANT4 tag $Name: $
29//
30//
31// Andrew Walkden 7th February 1997
32// G4OpenGLXViewer : Class to provide XWindows specific
33// functionality for OpenGL in GEANT4
34
35#ifdef G4VIS_BUILD_OPENGLX_DRIVER
36
37#include "G4OpenGLXViewer.hh"
38#include "G4VViewer.hh"
39#include "G4OpenGLSceneHandler.hh"
40#include <GL/glu.h>
41
42#include "G4OpenGLFontBaseStore.hh"
43
44#include <sstream>
45
46#include "G4VisExtent.hh"
47#include "G4LogicalVolume.hh"
48#include "G4VSolid.hh"
49#include "G4Point3D.hh"
50#include "G4Normal3D.hh"
51#include "G4StateManager.hh"
52
53#include <X11/Xatom.h>
54#include <X11/Xutil.h>
55#include <X11/Xmu/StdCmap.h>
56
57#include <assert.h>
58
59int G4OpenGLXViewer::snglBuf_RGBA[12] =
60{ GLX_RGBA,
61 GLX_RED_SIZE, 1,
62 GLX_GREEN_SIZE, 1,
63 GLX_BLUE_SIZE, 1,
64 GLX_DEPTH_SIZE, 1,
65 GLX_STENCIL_SIZE, 1,
66 None };
67
68int G4OpenGLXViewer::dblBuf_RGBA[13] =
69{ GLX_RGBA,
70 GLX_RED_SIZE, 1,
71 GLX_GREEN_SIZE, 1,
72 GLX_BLUE_SIZE, 1,
73 GLX_DOUBLEBUFFER,
74 GLX_DEPTH_SIZE, 1,
75 GLX_STENCIL_SIZE, 1,
76 None };
77
78#define NewString(str) \
79 ((str) != NULL ? (strcpy((char*)malloc((unsigned)strlen(str) + 1), str)) : (char*)NULL)
80
81#define USE_DEFAULT_COLORMAP 1
82#define USE_STANDARD_COLORMAP 0
83
84XVisualInfo* G4OpenGLXViewer::vi_single_buffer = 0;
85XVisualInfo* G4OpenGLXViewer::vi_double_buffer = 0;
86
87extern "C" {
88 static Bool G4OpenGLXViewerWaitForNotify (Display*, XEvent* e, char* arg) {
89 return (e->type == MapNotify) && (e->xmap.window == (Window) arg);
90 }
91}
92
93void G4OpenGLXViewer::SetView () {
94#ifdef G4DEBUG_VIS_OGL
95 printf("G4OpenGLXViewer::SetView \n");
96#endif
97 Bool success = glXMakeCurrent (dpy, win, cx);
98 if (!success) {
99 fViewId = -1; // This flags an error.
100 G4cerr << "G4OpenGLViewer::G4OpenGLViewer failed to attach a GLX context."
101 << G4endl;
102 GLint error = GL_NO_ERROR;
103 while ((error = glGetError()) != GL_NO_ERROR) {
104 G4cout << "GL Error: " << gluErrorString(error) << G4endl;
105 }
106 return;
107 }
108 G4OpenGLViewer::SetView ();
109}
110
111void G4OpenGLXViewer::ShowView () {
112 glXWaitGL (); //Wait for effects of all previous OpenGL commands to
113 //be propagated before progressing.
114 glFlush ();
115
116 if (fVP.IsPicking()) {
117 G4cout <<
118 "Window activated for picking (left-mouse), exit (middle-mouse)."
119 << G4endl;
120 while (true) {
121 if (XPending(dpy)) {
122 XNextEvent(dpy, &event);
123 if (event.type == ButtonPress && event.xbutton.button == 1) {
124 Pick(event.xbutton.x, event.xbutton.y);
125 }
126 else if (event.type == ButtonPress && event.xbutton.button == 2) break;
127 }
128 }
129 }
130}
131
132void G4OpenGLXViewer::GetXConnection () {
133// get a connection.
134 dpy = XOpenDisplay (0);
135 if (!dpy) {
136 fViewId = -1; // This flags an error.
137 G4cerr << "G4OpenGLViewer::G4OpenGLViewer couldn't open display." << G4endl;
138 return;
139 }
140
141// make sure OpenGL is supported and installed properly.
142 if (!glXQueryExtension (dpy, &errorBase, &eventBase)) {
143 fViewId = -1; // This flags an error.
144 G4cerr << "G4OpenGLViewer::G4OpenGLViewer X Server has no GLX extension."
145 << G4endl;
146 return;
147 }
148
149}
150
151void G4OpenGLXViewer::CreateGLXContext (XVisualInfo* v) {
152
153 vi = v;
154// get window's attributes
155 if (!XGetWindowAttributes(dpy, XRootWindow (dpy, vi -> screen), &xwa)) {
156 fViewId = -1; // This flags an error.
157 G4cerr << "G4OpenGLViewer::G4OpenGLViewer couldn't return window attributes"
158 << G4endl;
159 return;
160 }
161
162// create a GLX context
163 cx = glXCreateContext (dpy, vi, 0, true);
164 if (!cx) {
165 fViewId = -1; // This flags an error.
166 G4cerr << "G4OpenGLViewer::G4OpenGLViewer couldn't create context."
167 << G4endl;
168 return;
169 }
170
171// New stab at getting a colormap
172
173 Status status;
174 XStandardColormap *standardCmaps = XAllocStandardColormap ();
175 int i, numCmaps;
176
177 status = XmuLookupStandardColormap (dpy,
178 vi -> screen,
179 vi -> visualid,
180 vi -> depth,
181 XA_RGB_DEFAULT_MAP,
182 False,
183 True);
184
185 if (status == 1) {
186 cmap = 0;
187 status = XGetRGBColormaps (dpy,
188 XRootWindow (dpy, vi -> screen),
189 &standardCmaps,
190 &numCmaps,
191 XA_RGB_DEFAULT_MAP);
192 if (status == 1)
193 for (i = 0; i < numCmaps; i++) {
194 if (standardCmaps[i].visualid == vi -> visualid) {
195 cmap = standardCmaps[i].colormap;
196 XFree (standardCmaps);
197 break;
198 }
199 }
200 if (!cmap) {
201 fViewId = -1; // This flags an error.
202 G4cerr <<
203 "G4OpenGLViewer::G4OpenGLViewer failed to allocate a standard colormap."
204 << G4endl;
205 return;
206 }
207 G4cout << "Got standard cmap" << G4endl;
208 } else {
209 cmap = XCreateColormap (dpy,
210 XRootWindow(dpy, vi -> screen),
211 vi -> visual,
212 AllocNone);
213 G4cout << "Created own cmap" << G4endl;
214 }
215
216 if (!cmap) {
217 fViewId = -1; // This flags an error.
218 G4cerr << "G4OpenGLViewer::G4OpenGLViewer failed to allocate a Colormap."
219 << G4endl;
220 return;
221 }
222
223}
224
225void G4OpenGLXViewer::CreateMainWindow () {
226
227// create a window
228 swa.colormap = cmap;
229 swa.border_pixel = 0;
230 swa.event_mask = ExposureMask | ButtonPressMask | StructureNotifyMask;
231 swa.backing_store = WhenMapped;
232
233 // Window size and position...
234 size_hints = XAllocSizeHints();
235
236 fWinSize_x = fVP.GetWindowSizeHintX();
237 fWinSize_y = fVP.GetWindowSizeHintY();
238 G4int x_origin = fVP.GetWindowAbsoluteLocationHintX(DisplayWidth(dpy, vi -> screen));
239
240 // FIXME, screen size != window size on MAC, but I don't know have to get the menuBar
241 // size on MAC. L.Garnier 01/2009
242 G4int y_origin = fVP.GetWindowAbsoluteLocationHintY(DisplayHeight(dpy, vi -> screen));
243
244 size_hints->base_width = fWinSize_x;
245 size_hints->base_height = fWinSize_y;
246 size_hints->x = x_origin;
247 size_hints->y = y_origin;
248 if (fVP.IsWindowSizeHintX () && fVP.IsWindowLocationHintX () && fVP.IsWindowLocationHintY ()) {
249 size_hints->flags |= PSize | PPosition;
250 } else if (fVP.IsWindowSizeHintX () && !(fVP.IsWindowLocationHintX () || fVP.IsWindowLocationHintY ())) {
251 size_hints->flags |= PSize;
252 } else if ((!fVP.IsWindowSizeHintX ()) && fVP.IsWindowLocationHintX () && fVP.IsWindowLocationHintY ()) {
253 size_hints->flags |= PPosition;
254 }
255 G4cout << "Window name: " << fName << G4endl;
256 strncpy (charViewName, fName, 100);
257 char *window_name = charViewName;
258 char *icon_name = charViewName;
259 //char tmpatom[] = "XA_WM_NORMAL_HINTS";
260 wm_hints = XAllocWMHints();
261 class_hints = XAllocClassHint();
262
263 XStringListToTextProperty (&window_name, 1, &windowName);
264 XStringListToTextProperty (&icon_name, 1, &iconName);
265
266 wm_hints -> initial_state = NormalState;
267 wm_hints -> input = True;
268 wm_hints -> icon_pixmap = icon_pixmap;
269 wm_hints -> flags = StateHint | IconPixmapHint | InputHint;
270
271 class_hints -> res_name = NewString("G4OpenGL");
272 class_hints -> res_class = NewString("G4OpenGL");
273
274 win = XCreateWindow (dpy, XRootWindow (dpy, vi -> screen), x_origin,
275 y_origin, fWinSize_x, fWinSize_y, 0, vi -> depth,
276 InputOutput, vi -> visual,
277 CWBorderPixel | CWColormap |
278 CWEventMask | CWBackingStore,
279 &swa);
280
281 XSetWMProperties (dpy, win, &windowName, &iconName, 0, 0,
282 size_hints, wm_hints, class_hints);
283
284// request X to Draw window on screen.
285 XMapWindow (dpy, win);
286
287// Wait for window to appear (wait for an "expose" event).
288 XIfEvent (dpy, &event, G4OpenGLXViewerWaitForNotify, (char*) win);
289
290// connect the context to a window
291 Bool success = glXMakeCurrent (dpy, win, cx);
292 if (!success) {
293 fViewId = -1; // This flags an error.
294 G4cerr << "G4OpenGLViewer::G4OpenGLViewer failed to attach a GLX context."
295 << G4endl;
296 GLint error = GL_NO_ERROR;
297 while ((error = glGetError()) != GL_NO_ERROR) {
298 G4cout << "GL Error: " << gluErrorString(error) << G4endl;
299 }
300 return;
301 }
302
303}
304
305void G4OpenGLXViewer::CreateFontLists () {
306
307 std::map<G4double,G4String> fonts; // G4VMarker screen size and font name.
308 fonts[10.] = "-adobe-courier-bold-r-normal--10-100-75-75-m-60-iso8859-1";
309 fonts[11.] = "-adobe-courier-bold-r-normal--11-80-100-100-m-60-iso8859-1";
310 fonts[12.] = "-adobe-courier-bold-r-normal--12-120-75-75-m-70-iso8859-1";
311 fonts[13.] = "fixed";
312 fonts[14.] = "-adobe-courier-bold-r-normal--14-100-100-100-m-90-iso8859-1";
313 fonts[17.] = "-adobe-courier-bold-r-normal--17-120-100-100-m-100-iso8859-1";
314 fonts[18.] = "-adobe-courier-bold-r-normal--18-180-75-75-m-110-iso8859-1";
315 fonts[20.] = "-adobe-courier-bold-r-normal--20-140-100-100-m-110-iso8859-1";
316 fonts[24.] = "-adobe-courier-bold-r-normal--24-240-75-75-m-150-iso8859-1";
317 fonts[25.] = "-adobe-courier-bold-r-normal--25-180-100-100-m-150-iso8859-1";
318 fonts[34.] = "-adobe-courier-bold-r-normal--34-240-100-100-m-200-iso8859-1";
319 std::map<G4double,G4String>::const_iterator i;
320 for (i = fonts.begin(); i != fonts.end(); ++i) {
321 XFontStruct* font_info = XLoadQueryFont(dpy, i->second);
322 if (!font_info) {
323 G4cerr <<
324 "G4OpenGLXViewer: XLoadQueryFont failed for font\n "
325 << i->second
326 << G4endl;
327 continue;
328 }
329 G4int font_base = glGenLists(256);
330 if (!font_base) {
331 G4cerr << "G4OpenGLXViewer: out of display lists for fonts."
332 << G4endl;
333 continue;
334 }
335 G4int first = font_info->min_char_or_byte2;
336 G4int last = font_info->max_char_or_byte2;
337 glXUseXFont(font_info->fid, first, last-first+1,font_base+first);
338 G4OpenGLFontBaseStore::AddFontBase(this,font_base,i->first,i->second);
339 }
340}
341
342G4OpenGLXViewer::G4OpenGLXViewer (G4OpenGLSceneHandler& scene):
343G4VViewer (scene, -1),
344G4OpenGLViewer (scene),
345vi_immediate (0),
346vi_stored (0),
347vi (0),
348cmap (0)
349{
350 GetXConnection ();
351 if (fViewId < 0) return;
352
353 // Try for a visual suitable for OpenGLImmediate..
354 // first try for a single buffered RGB window
355 if (!vi_single_buffer) {
356 vi_single_buffer =
357 glXChooseVisual (dpy, XDefaultScreen (dpy), snglBuf_RGBA);
358 }
359 if (!vi_double_buffer) {
360 vi_double_buffer =
361 glXChooseVisual (dpy, XDefaultScreen (dpy), dblBuf_RGBA);
362 }
363
364 if (vi_single_buffer || vi_double_buffer) {
365 if (!vi_double_buffer) {
366 G4cout <<
367 "G4OpenGLXViewer::G4OpenGLXViewer: unable to get a double buffer visual."
368 "\n Working with a single buffer."
369 << G4endl;
370 }
371 } else {
372 if (!vi_single_buffer) {
373 G4cout <<
374 "G4OpenGLXViewer::G4OpenGLXViewer: unable to get a single buffer visual."
375 << G4endl;
376 }
377 if (!vi_double_buffer) {
378 G4cout <<
379 "G4OpenGLXViewer::G4OpenGLXViewer: unable to get a double buffer visual."
380 << G4endl;
381 }
382 }
383
384 if (vi_single_buffer) {
385 vi_immediate = vi_single_buffer;
386 attributeList = snglBuf_RGBA;
387 }
388
389 if (!vi_immediate){
390 // next try for a double buffered RGB, but Draw to top buffer
391 if (vi_double_buffer) {
392 vi_immediate = vi_double_buffer;
393 attributeList = dblBuf_RGBA;
394 }
395 }
396
397 // Now try for a visual suitable for OpenGLStored...
398 // Try for a double buffered RGB window
399 if (vi_double_buffer) {
400 vi_stored = vi_double_buffer;
401 attributeList = dblBuf_RGBA;
402 }
403
404 if (!vi_immediate || !vi_stored) {
405 G4cout <<
406 "G4OpenGLXViewer::G4OpenGLXViewer: unable to get required visuals."
407 << G4endl;
408 fViewId = -1; // This flags an error.
409 }
410
411 // glClearColor (0., 0., 0., 0.);
412 // glClearDepth (1.);
413}
414
415G4OpenGLXViewer::~G4OpenGLXViewer () {
416 if (fViewId >= 0) {
417 //Close a window from here
418 glXMakeCurrent (dpy, None, NULL);
419 glXDestroyContext (dpy, cx);
420 if (win) XDestroyWindow (dpy, win); // ...if already deleted in
421 // sub-class G4OpenGLXmViewer.
422 XFlush (dpy);
423 }
424}
425
426void G4OpenGLXViewer::printEPS() {
427
428#ifdef G4DEBUG_VIS_OGL
429 printf("G4OpenGLXViewer::print \n");
430#endif
431
432 //using namespace std;
433 //cout << "print_col_callback requested with file name: " << fPrintFilename << G4endl;
434
435 if (fVectoredPs) {
436#ifdef G4DEBUG_VIS_OGL
437 printf("G4OpenGLXViewer::print Vectored\n");
438#endif
439 G4OpenGLViewer::printEPS();
440 } else {
441#ifdef G4DEBUG_VIS_OGL
442 printf("G4OpenGLXViewer::print non Vectored\n");
443#endif
444 G4OpenGLViewer::printEPS();
445 return;
446
447
448
449 std::string fileTst = "G4OpenGL_XPixmapTestWithoutPixmap.eps";
450 generateEPSX (fileTst.c_str(),
451 fPrintColour,
452 fWinSize_x, fWinSize_y);
453
454
455
456
457
458
459// G4StateManager* stateManager = G4StateManager::GetStateManager();
460// G4ApplicationState oldState = stateManager->GetCurrentState();
461// stateManager->SetNewState(G4State_Idle);
462
463// printEPS ();
464
465// stateManager->SetNewState(oldState);
466
467// // fPrintFilename = fPrintFilename+"-Gl2ps.ps";
468// return;
469
470// save context before
471 XVisualInfo* tmp_vi = vi;
472 GLXDrawable tmp_win = win;
473 tmp_cx = cx;
474
475 XVisualInfo* pvi;
476 GLXContext pcx = create_GL_print_context(pvi);
477
478 if (!pcx) {
479 G4cout << "Unable to create print context." << G4endl;
480 return;
481 }
482
483#ifdef G4DEBUG_VIS_OGL
484 printf("G4OpenGLXViewer::print Create pixmap Size :%d %d --- %d %d %d\n",fWinSize_x, fWinSize_y,vi,win,cx);
485#endif
486 cx=pcx;
487
488 Pixmap pmap = XCreatePixmap (dpy,
489 XRootWindow (dpy, pvi->screen),
490 fWinSize_x, fWinSize_y,
491 pvi->depth);
492
493
494 if (!pmap) {
495 G4cout << "Unable to create pixmap." << G4endl;
496 return;
497 }
498
499
500 GLXPixmap glxpmap = glXCreateGLXPixmap (dpy,
501 pvi,
502 pmap);
503
504 if (!glxpmap) {
505 G4cout << "Unable to create glx pixmap." << G4endl;
506 return;
507 }
508
509
510 win=glxpmap;
511
512// int winX=fWinSize_x;
513// int winY=fWinSize_y;
514
515 //#define CHECK_MULTIPLE_PRINT 1
516#ifdef CHECK_MULTIPLE_PRINT
517 for (int tstX = 3000-2;tstX <=3000+2;tstX++) {
518 for (int tstY = 3000-2;tstY <=3000+2;tstY++) {
519 fWinSize_y = tstY;
520 fWinSize_x = tstX;
521 std::string file = "G4OpenGL_XPixmap";
522 file += tstX;
523 file +="x";
524 file +=tstY;
525 file +=".eps";
526#else
527 std::string file = fPrintFilename.c_str();
528#endif
529
530 // clear the buffers and window.
531 SetView();
532 ClearView ();
533
534#ifdef G4DEBUG_VIS_OGL
535 printf("G4OpenGLXViewer::print Call DrawView \n");
536#endif
537
538
539
540 // Need to force redraw for SXm mode
541 NeedKernelVisit ();
542
543 // Need to change state to IDLE
544 G4StateManager* stateManager = G4StateManager::GetStateManager();
545 G4ApplicationState oldState = stateManager->GetCurrentState();
546 stateManager->SetNewState(G4State_Idle);
547
548
549
550 DrawView (); // Will make current glX
551
552 // Restore state
553 stateManager->SetNewState(oldState);
554
555
556
557
558 generateEPSX (file.c_str(),
559 fPrintColour,
560 fWinSize_x, fWinSize_y);
561
562#ifdef CHECK_MULTIPLE_PRINT
563 }
564 }
565 fWinSize_y = winY;
566 fWinSize_x = winX;
567#endif
568 vi = tmp_vi;
569 win = tmp_win;
570 cx = tmp_cx;
571
572 glXMakeCurrent (dpy, win, cx);
573 // XVisualInfo* pvi = glXChooseVisual (dpy,
574 // XDefaultScreen (dpy),
575 // snglBuf_RGBA);
576
577 // if (!pvi) {
578 // pvi = glXChooseVisual (dpy,
579 // XDefaultScreen (dpy),
580 // dblBuf_RGBA);
581 // }
582
583#ifdef G4DEBUG_VIS_OGL
584 printf("G4OpenGLXViewer::print Restored %d %d %d\n",vi,win,cx);
585#endif
586 // printf("Error 1:%d 2:%d\n",er1,er2);
587
588
589 // Free print context
590 XFreePixmap(dpy,pmap);
591 glXDestroyContext(dpy,pcx);
592 glXDestroyGLXPixmap(dpy,glxpmap);
593
594 // Restore view in display context
595 SetView();
596
597 }
598
599}
600
601
602GLXContext G4OpenGLXViewer::create_GL_print_context(XVisualInfo*& pvi) {
603
604 pvi = glXChooseVisual (dpy,
605 XDefaultScreen (dpy),
606 snglBuf_RGBA);
607
608 if (!pvi) {
609 pvi = glXChooseVisual (dpy,
610 XDefaultScreen (dpy),
611 dblBuf_RGBA);
612 }
613
614// GLXFBConfig *fbc;
615// XVisualInfo *vi;
616// Colormap cmap;
617// XSetWindowAttributes swa;
618// Window win;
619// GLXContext cx;
620// GLXWindow gwin;
621// XEvent event;
622// int nelements;
623
624// /* Find a FBConfig that uses RGBA. Note that no attribute list is */
625// /* needed since GLX_RGBA_BIT is a default attribute. */
626// fbc = glXChooseFBConfig(dpy,XRootWindow (dpy, pvi->screen), 0, &nelements);
627// vi = glXGetVisualFromFBConfig(dpy, fbc[0]);
628
629// /* Create a GLX context using the first FBConfig in the list. */
630// return glXCreateNewContext(dpy, fbc[0], GLX_RGBA_TYPE, 0, GL_FALSE);
631
632
633
634 return glXCreateContext (dpy,
635 pvi,
636 0,
637 False);
638}
639
640
641bool G4OpenGLXViewer::grabPixelsX (unsigned int width, unsigned int height,GLenum format,GLubyte* buffer) {
642#ifdef G4DEBUG_VIS_OGL
643 GLint viewport[4];
644 glGetIntegerv(GL_VIEWPORT, viewport);
645 printf("G4OpenGLXViewer::grabPixelsX %d %d viewport %d %d %d %d\n",width,height,viewport[0],viewport[1],viewport[2],viewport[3]);
646#endif
647
648 GLint swapbytes, lsbfirst, rowlength;
649 GLint skiprows, skippixels, alignment;
650
651 unsigned int lineSize = 0;
652 if (format == GL_RGB){
653 lineSize = width*3;
654 } else {
655 lineSize = width*1;
656 }
657
658 GLubyte* lineBuffer = new GLubyte[lineSize];
659 if (lineBuffer == NULL)
660 return false;
661 for (unsigned int y = 0; y<lineSize; y++) {
662 lineBuffer[y] = 0;
663 }
664
665 glGetIntegerv (GL_UNPACK_SWAP_BYTES, &swapbytes);
666 glGetIntegerv (GL_UNPACK_LSB_FIRST, &lsbfirst);
667 glGetIntegerv (GL_UNPACK_ROW_LENGTH, &rowlength);
668
669 glGetIntegerv (GL_UNPACK_SKIP_ROWS, &skiprows);
670 glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &skippixels);
671 glGetIntegerv (GL_UNPACK_ALIGNMENT, &alignment);
672
673 glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
674 glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
675 glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
676
677 glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
678 glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
679 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
680
681 // FIXME L.Garnier 25 03 2009
682 // Try to read at first a block of width by height
683 // But on mac osX 10.5.6 on some window size their is
684 // some stranges effects:
685 // Pixels should came 3 values by 3 values but on border
686 // it seems that with some window size there is a lack of
687 // 1 or 2 values. For example a gray level picture like
688 // (1,1,1) (2,2,2) (3,3,3)
689 // (4,4,4) (5,5,5) (6,6,6)
690 // (7,7,7) (8,8,8) (9,9,9)
691 // appear as (with all buffer values init to 999) :
692 // (1,1,1) (2,2,2) (3,3,3)
693 // (999,999,4) (4,4,5) (5,5,6)
694 // (6,6,999) (999,999,7) (7,7,8)
695 // STRANGE EFFECT....
696
697 // Then we read line by line...and NO problem !
698
699
700 glReadBuffer(GL_FRONT);
701 for (unsigned int i=0;i<height;i++) {
702 glReadPixels (0, i, (GLsizei)width, 1, format, GL_UNSIGNED_BYTE, (GLvoid*) lineBuffer);
703 glXWaitGL (); //Wait for effects of all previous OpenGL commands to
704 // printf("\n%d ",i);
705 for (unsigned int j=0;j<lineSize;j++) {
706 buffer[j+i*lineSize] = lineBuffer[j];
707 // printf("%d ",buffer[j]);
708 }
709 }
710 // //be propagated before progressing.
711#ifdef G4DEBUG_VIS_OGL
712 printf("G4OpenGLXViewer::GrabPixelX flush\n");
713#endif
714 glFlush ();
715
716 delete [] lineBuffer;
717
718 glPixelStorei (GL_UNPACK_SWAP_BYTES, swapbytes);
719 glPixelStorei (GL_UNPACK_LSB_FIRST, lsbfirst);
720 glPixelStorei (GL_UNPACK_ROW_LENGTH, rowlength);
721
722 glPixelStorei (GL_UNPACK_SKIP_ROWS, skiprows);
723 glPixelStorei (GL_UNPACK_SKIP_PIXELS, skippixels);
724 glPixelStorei (GL_UNPACK_ALIGNMENT, alignment);
725
726
727 return true;
728}
729
730int G4OpenGLXViewer::generateEPSX (const char* filnam,
731 int inColour,
732 unsigned int width,
733 unsigned int height) {
734
735 FILE* fp;
736 GLubyte* pixels;
737 GLubyte* curpix;
738 int components;
739
740 GLenum format;
741 int size;
742
743 if (inColour) {
744 format = GL_RGB;
745 size = width*height*3;
746 } else {
747 format = GL_LUMINANCE;
748 size = width*height*1;
749 }
750
751 pixels = new GLubyte[size];
752 if (pixels == NULL)
753 return NULL;
754 for (int y = 0; y<size; y++) {
755 pixels[y] = 0;
756 }
757
758
759#ifdef G4DEBUG_VIS_OGL
760 printf("G4OpenGLXViewer::generateEPSX\n");
761#endif
762
763
764 if (!grabPixelsX (width, height,format,pixels)) {
765 return 1;
766 }
767#ifdef G4DEBUG_VIS_OGL
768 printf("--\n--\n--\n");
769#endif
770
771 if (inColour) {
772 components = 3;
773 } else {
774 components = 1;
775 }
776
777 fp = fopen (filnam, "w");
778 if (fp == NULL) {
779 return 2;
780 }
781
782 fprintf (fp, "%%!PS-Adobe-2.0 EPSF-1.2\n");
783 fprintf (fp, "%%%%Title: %s\n", filnam);
784 fprintf (fp, "%%%%Creator: OpenGL pixmap render output\n");
785 fprintf (fp, "%%%%BoundingBox: 0 0 %d %d\n", width, height);
786 fprintf (fp, "%%%%EndComments\n");
787 fprintf (fp, "gsave\n");
788 fprintf (fp, "/bwproc {\n");
789 fprintf (fp, " rgbproc\n");
790 fprintf (fp, " dup length 3 idiv string 0 3 0 \n");
791 fprintf (fp, " 5 -1 roll {\n");
792 fprintf (fp, " add 2 1 roll 1 sub dup 0 eq\n");
793 fprintf (fp, " { pop 3 idiv 3 -1 roll dup 4 -1 roll dup\n");
794 fprintf (fp, " 3 1 roll 5 -1 roll } put 1 add 3 0 \n");
795 fprintf (fp, " { 2 1 roll } ifelse\n");
796 fprintf (fp, " }forall\n");
797 fprintf (fp, " pop pop pop\n");
798 fprintf (fp, "} def\n");
799 fprintf (fp, "systemdict /colorimage known not {\n");
800 fprintf (fp, " /colorimage {\n");
801 fprintf (fp, " pop\n");
802 fprintf (fp, " pop\n");
803 fprintf (fp, " /rgbproc exch def\n");
804 fprintf (fp, " { bwproc } image\n");
805 fprintf (fp, " } def\n");
806 fprintf (fp, "} if\n");
807 fprintf (fp, "/picstr %d string def\n", width * components);
808 fprintf (fp, "%d %d scale\n", width, height);
809 fprintf (fp, "%d %d %d\n", width, height, 8);
810 fprintf (fp, "[%d 0 0 %d 0 0]\n", width, height);
811 fprintf (fp, "{currentfile picstr readhexstring pop}\n");
812 fprintf (fp, "false %d\n", components);
813 fprintf (fp, "colorimage\n");
814
815 curpix = (GLubyte*) pixels;
816 unsigned int pos = 0;
817 for (unsigned int i = width*height*components; i>0; i--) {
818 fprintf (fp, "%02hx ", *(curpix++));
819 if (++pos >= width) {
820 // if (++pos >= 32) {
821 fprintf (fp, "\n");
822 pos = 0;
823 }
824 }
825 if (pos)
826 fprintf (fp, "\n");
827
828 fprintf (fp, "grestore\n");
829 fprintf (fp, "showpage\n");
830 delete pixels;
831 fclose (fp);
832
833#ifdef G4DEBUG_VIS_OGL
834 printf("G4OpenGLXViewer::generateEPSX END\n");
835#endif
836
837 return 0;
838}
839
840
841#endif
Note: See TracBrowser for help on using the repository browser.