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

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

Modif pour XGeometry complet. Avec debug
  • Property svn:mime-type set to text/cpp
File size: 19.0 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.42 2007/05/25 10:47:17 allison Exp $
28// GEANT4 tag $Name: HEAD $
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
39#include "G4OpenGLFontBaseStore.hh"
40
41#include <sstream>
42
43#include "G4VisExtent.hh"
44#include "G4LogicalVolume.hh"
45#include "G4VSolid.hh"
46#include "G4Point3D.hh"
47#include "G4Normal3D.hh"
48
49#include <X11/Xatom.h>
50#include <X11/Xutil.h>
51
52#include <assert.h>
53
54int G4OpenGLXViewer::snglBuf_RGBA[12] =
55{ GLX_RGBA,
56 GLX_RED_SIZE, 1,
57 GLX_GREEN_SIZE, 1,
58 GLX_BLUE_SIZE, 1,
59 GLX_DEPTH_SIZE, 1,
60 GLX_STENCIL_SIZE, 1,
61 None };
62
63int G4OpenGLXViewer::dblBuf_RGBA[13] =
64{ GLX_RGBA,
65 GLX_RED_SIZE, 1,
66 GLX_GREEN_SIZE, 1,
67 GLX_BLUE_SIZE, 1,
68 GLX_DOUBLEBUFFER,
69 GLX_DEPTH_SIZE, 1,
70 GLX_STENCIL_SIZE, 1,
71 None };
72
73#define NewString(str) \
74 ((str) != NULL ? (strcpy((char*)malloc((unsigned)strlen(str) + 1), str)) : (char*)NULL)
75
76#define USE_DEFAULT_COLORMAP 1
77#define USE_STANDARD_COLORMAP 0
78
79XVisualInfo* G4OpenGLXViewer::vi_single_buffer = 0;
80XVisualInfo* G4OpenGLXViewer::vi_double_buffer = 0;
81
82extern "C" {
83 static Bool G4OpenGLXViewerWaitForNotify (Display*, XEvent* e, char* arg) {
84 return (e->type == MapNotify) && (e->xmap.window == (Window) arg);
85 }
86}
87
88void G4OpenGLXViewer::SetView () {
89 glXMakeCurrent (dpy, win, cx);
90 G4OpenGLViewer::SetView ();
91}
92
93void G4OpenGLXViewer::ShowView () {
94 glXWaitGL (); //Wait for effects of all previous OpenGL commands to
95 //be propagated before progressing.
96 glFlush ();
97
98 if (fVP.IsPicking()) {
99 G4cout <<
100 "Window activated for picking (left-mouse), exit (middle-mouse)."
101 << G4endl;
102 while (true) {
103 if (XPending(dpy)) {
104 XNextEvent(dpy, &event);
105 if (event.type == ButtonPress && event.xbutton.button == 1) {
106 Pick(event.xbutton.x, event.xbutton.y);
107 }
108 else if (event.type == ButtonPress && event.xbutton.button == 2) break;
109 }
110 }
111 }
112}
113
114void G4OpenGLXViewer::GetXConnection () {
115// get a connection.
116 dpy = XOpenDisplay (0);
117 if (!dpy) {
118 fViewId = -1; // This flags an error.
119 G4cerr << "G4OpenGLViewer::G4OpenGLViewer couldn't open display." << G4endl;
120 return;
121 }
122
123// make sure OpenGL is supported and installed properly.
124 if (!glXQueryExtension (dpy, &errorBase, &eventBase)) {
125 fViewId = -1; // This flags an error.
126 G4cerr << "G4OpenGLViewer::G4OpenGLViewer X Server has no GLX extension."
127 << G4endl;
128 return;
129 }
130
131}
132
133void G4OpenGLXViewer::CreateGLXContext (XVisualInfo* v) {
134
135 vi = v;
136// get window's attributes
137 if (!XGetWindowAttributes(dpy, XRootWindow (dpy, vi -> screen), &xwa)) {
138 fViewId = -1; // This flags an error.
139 G4cerr << "G4OpenGLViewer::G4OpenGLViewer couldn't return window attributes"
140 << G4endl;
141 return;
142 }
143
144// create a GLX context
145 cx = glXCreateContext (dpy, vi, 0, true);
146 if (!cx) {
147 fViewId = -1; // This flags an error.
148 G4cerr << "G4OpenGLViewer::G4OpenGLViewer couldn't create context."
149 << G4endl;
150 return;
151 }
152
153// New stab at getting a colormap
154
155 Status status;
156 XStandardColormap *standardCmaps = XAllocStandardColormap ();
157 int i, numCmaps;
158
159 status = XmuLookupStandardColormap (dpy,
160 vi -> screen,
161 vi -> visualid,
162 vi -> depth,
163 XA_RGB_DEFAULT_MAP,
164 False,
165 True);
166
167 if (status == 1) {
168 cmap = 0;
169 status = XGetRGBColormaps (dpy,
170 XRootWindow (dpy, vi -> screen),
171 &standardCmaps,
172 &numCmaps,
173 XA_RGB_DEFAULT_MAP);
174 if (status == 1)
175 for (i = 0; i < numCmaps; i++) {
176 if (standardCmaps[i].visualid == vi -> visualid) {
177 cmap = standardCmaps[i].colormap;
178 XFree (standardCmaps);
179 break;
180 }
181 }
182 if (!cmap) {
183 fViewId = -1; // This flags an error.
184 G4cerr <<
185 "G4OpenGLViewer::G4OpenGLViewer failed to allocate a standard colormap."
186 << G4endl;
187 return;
188 }
189 G4cout << "Got standard cmap" << G4endl;
190 } else {
191 cmap = XCreateColormap (dpy,
192 XRootWindow(dpy, vi -> screen),
193 vi -> visual,
194 AllocNone);
195 G4cout << "Created own cmap" << G4endl;
196 }
197
198 if (!cmap) {
199 fViewId = -1; // This flags an error.
200 G4cerr << "G4OpenGLViewer::G4OpenGLViewer failed to allocate a Colormap."
201 << G4endl;
202 return;
203 }
204
205}
206
207void G4OpenGLXViewer::CreateMainWindow () {
208
209// create a window
210 swa.colormap = cmap;
211 swa.border_pixel = 0;
212 swa.event_mask = ExposureMask | ButtonPressMask | StructureNotifyMask;
213 swa.backing_store = WhenMapped;
214
215 // Window size and position...
216 unsigned int width, height;
217 x_origin = 0;
218 y_origin = 0;
219 size_hints = XAllocSizeHints();
220
221 // already done in G4VViewer at creation
222
223// const G4String& XGeometryString = fVP.GetXGeometryString();
224// int screen_num = DefaultScreen(dpy);
225// if (!XGeometryString.empty()) {
226// G4int geometryResultMask = XParseGeometry
227// ((char*)XGeometryString.c_str(),
228// &x_origin, &y_origin, &width, &height);
229// if (geometryResultMask & (WidthValue | HeightValue)) {
230// if (geometryResultMask & XValue) {
231// if (geometryResultMask & XNegative) {
232// x_origin = DisplayWidth(dpy, screen_num) + x_origin - width;
233// }
234// size_hints->flags |= PPosition;
235// size_hints->x = x_origin;
236// }
237// if (geometryResultMask & YValue) {
238// if (geometryResultMask & YNegative) {
239// y_origin = DisplayHeight(dpy, screen_num) + y_origin - height;
240// }
241// size_hints->flags |= PPosition;
242// size_hints->y = y_origin;
243// }
244// } else {
245// G4cout << "ERROR: Geometry string \""
246// << XGeometryString
247// << "\" invalid. Using \"600x600\"."
248// << G4endl;
249// width = 600;
250// height = 600;
251// }
252// }
253// size_hints->width = width;
254// size_hints->height = height;
255
256#ifdef G4DEBUG
257 printf("G4OpenGLXViewer::CreateMainWindow CreateWindow Mauvais Size:W:%d X:%d H:%d Y:%d \n",width,fVP.GetWindowSizeHintX(),height, fVP.GetWindowSizeHintY());
258#endif
259
260
261 Window root_return;
262 int x_return, y_return;
263 unsigned int width_return, height_return;
264 unsigned int border_width_return;
265 unsigned int depth_return;
266
267#ifdef G4DEBUG
268 printf("G4OpenGLXViewer::CreateMainWindow 1\n");
269#endif
270 // get the parent window's geometry
271 XGetGeometry(dpy, XRootWindow (dpy, vi -> screen), &root_return, &x_return, &y_return,
272 &width_return, &height_return, &border_width_return,
273 &depth_return);
274
275#ifdef G4DEBUG
276 printf("G4OpenGLXViewer::CreateMainWindow 2 root W :%d H :%d\n",width_return, height_return);
277#endif
278
279 // G4int WinSize_x;
280 // G4int WinSize_y;
281 WinSize_x = fVP.GetWindowSizeHintX();
282 WinSize_y = fVP.GetWindowSizeHintY();
283 x_origin = fVP.GetWindowAbsoluteLocationHintX(width_return);
284 y_origin = fVP.GetWindowAbsoluteLocationHintY(height_return);
285
286 size_hints->base_width = WinSize_x;
287 size_hints->base_height = WinSize_y;
288 size_hints->x = x_origin;
289 size_hints->y = y_origin;
290 size_hints->flags |= PSize | PPosition;
291#ifdef G4DEBUG
292 printf("G4OpenGLXViewer::CreateMainWindow CreateWindow Size:W:%d H:%d X:%d Y:%d \n",WinSize_x,WinSize_y,x_origin,y_origin);
293#endif
294
295 G4cout << "Window name: " << fName << G4endl;
296 strncpy (charViewName, fName, 100);
297 char *window_name = charViewName;
298 char *icon_name = charViewName;
299 //char tmpatom[] = "XA_WM_NORMAL_HINTS";
300 wm_hints = XAllocWMHints();
301 class_hints = XAllocClassHint();
302
303 XStringListToTextProperty (&window_name, 1, &windowName);
304 XStringListToTextProperty (&icon_name, 1, &iconName);
305
306 wm_hints -> initial_state = NormalState;
307 wm_hints -> input = True;
308 wm_hints -> icon_pixmap = icon_pixmap;
309 wm_hints -> flags = StateHint | IconPixmapHint | InputHint;
310
311 class_hints -> res_name = NewString("G4OpenGL");
312 class_hints -> res_class = NewString("G4OpenGL");
313
314 win = XCreateWindow (dpy, XRootWindow (dpy, vi -> screen), x_origin,
315 y_origin, WinSize_x, WinSize_y, 0, vi -> depth,
316 InputOutput, vi -> visual,
317 CWBorderPixel | CWColormap |
318 CWEventMask | CWBackingStore,
319 &swa);
320
321 XSetWMProperties (dpy, win, &windowName, &iconName, 0, 0,
322 size_hints, wm_hints, class_hints);
323
324// request X to Draw window on screen.
325 XMapWindow (dpy, win);
326
327// Wait for window to appear (wait for an "expose" event).
328 XIfEvent (dpy, &event, G4OpenGLXViewerWaitForNotify, (char*) win);
329
330// connect the context to a window
331 Bool success = glXMakeCurrent (dpy, win, cx);
332 if (!success) {
333 fViewId = -1; // This flags an error.
334 G4cerr << "G4OpenGLViewer::G4OpenGLViewer failed to attach a GLX context."
335 << G4endl;
336 GLint error = GL_NO_ERROR;
337 while ((error = glGetError()) != GL_NO_ERROR) {
338 G4cout << "GL Error: " << gluErrorString(error) << G4endl;
339 }
340 return;
341 }
342
343}
344
345void G4OpenGLXViewer::CreateFontLists () {
346
347 std::map<G4double,G4String> fonts; // G4VMarker screen size and font name.
348 fonts[10.] = "-adobe-courier-bold-r-normal--10-100-75-75-m-60-iso8859-1";
349 fonts[11.] = "-adobe-courier-bold-r-normal--11-80-100-100-m-60-iso8859-1";
350 fonts[12.] = "-adobe-courier-bold-r-normal--12-120-75-75-m-70-iso8859-1";
351 fonts[13.] = "fixed";
352 fonts[14.] = "-adobe-courier-bold-r-normal--14-100-100-100-m-90-iso8859-1";
353 fonts[17.] = "-adobe-courier-bold-r-normal--17-120-100-100-m-100-iso8859-1";
354 fonts[18.] = "-adobe-courier-bold-r-normal--18-180-75-75-m-110-iso8859-1";
355 fonts[20.] = "-adobe-courier-bold-r-normal--20-140-100-100-m-110-iso8859-1";
356 fonts[24.] = "-adobe-courier-bold-r-normal--24-240-75-75-m-150-iso8859-1";
357 fonts[25.] = "-adobe-courier-bold-r-normal--25-180-100-100-m-150-iso8859-1";
358 fonts[34.] = "-adobe-courier-bold-r-normal--34-240-100-100-m-200-iso8859-1";
359 std::map<G4double,G4String>::const_iterator i;
360 for (i = fonts.begin(); i != fonts.end(); ++i) {
361 XFontStruct* font_info = XLoadQueryFont(dpy, i->second);
362 if (!font_info) {
363 G4cerr <<
364 "G4OpenGLXViewer: XLoadQueryFont failed for font\n "
365 << i->second
366 << G4endl;
367 continue;
368 }
369 G4int font_base = glGenLists(256);
370 if (!font_base) {
371 G4cerr << "G4OpenGLXViewer: out of display lists for fonts."
372 << G4endl;
373 continue;
374 }
375 G4int first = font_info->min_char_or_byte2;
376 G4int last = font_info->max_char_or_byte2;
377 glXUseXFont(font_info->fid, first, last-first+1,font_base+first);
378 G4OpenGLFontBaseStore::AddFontBase(this,font_base,i->first,i->second);
379 }
380}
381
382G4OpenGLXViewer::G4OpenGLXViewer (G4OpenGLSceneHandler& scene):
383G4VViewer (scene, -1),
384G4OpenGLViewer (scene),
385vi_immediate (0),
386vi_stored (0),
387vi (0),
388cmap (0)
389{
390 GetXConnection ();
391 if (fViewId < 0) return;
392
393 // Try for a visual suitable for OpenGLImmediate..
394 // first try for a single buffered RGB window
395 if (!vi_single_buffer) {
396 vi_single_buffer =
397 glXChooseVisual (dpy, XDefaultScreen (dpy), snglBuf_RGBA);
398 }
399 if (!vi_double_buffer) {
400 vi_double_buffer =
401 glXChooseVisual (dpy, XDefaultScreen (dpy), dblBuf_RGBA);
402 }
403
404 if (vi_single_buffer || vi_double_buffer) {
405 if (!vi_double_buffer) {
406 G4cout <<
407 "G4OpenGLXViewer::G4OpenGLXViewer: unable to get a double buffer visual."
408 "\n Working with a single buffer."
409 << G4endl;
410 }
411 } else {
412 if (!vi_single_buffer) {
413 G4cout <<
414 "G4OpenGLXViewer::G4OpenGLXViewer: unable to get a single buffer visual."
415 << G4endl;
416 }
417 if (!vi_double_buffer) {
418 G4cout <<
419 "G4OpenGLXViewer::G4OpenGLXViewer: unable to get a double buffer visual."
420 << G4endl;
421 }
422 }
423
424 if (vi_single_buffer) {
425 vi_immediate = vi_single_buffer;
426 attributeList = snglBuf_RGBA;
427 }
428
429 if (!vi_immediate){
430 // next try for a double buffered RGB, but Draw to top buffer
431 if (vi_double_buffer) {
432 vi_immediate = vi_double_buffer;
433 attributeList = dblBuf_RGBA;
434 }
435 }
436
437 // Now try for a visual suitable for OpenGLStored...
438 // Try for a double buffered RGB window
439 if (vi_double_buffer) {
440 vi_stored = vi_double_buffer;
441 attributeList = dblBuf_RGBA;
442 }
443
444 if (!vi_immediate || !vi_stored) {
445 G4cout <<
446 "G4OpenGLXViewer::G4OpenGLXViewer: unable to get required visuals."
447 << G4endl;
448 fViewId = -1; // This flags an error.
449 }
450
451 // glClearColor (0., 0., 0., 0.);
452 // glClearDepth (1.);
453}
454
455G4OpenGLXViewer::~G4OpenGLXViewer () {
456 if (fViewId >= 0) {
457 //Close a window from here
458 glXMakeCurrent (dpy, None, NULL);
459 glXDestroyContext (dpy, cx);
460 if (win) XDestroyWindow (dpy, win); // ...if already deleted in
461 // sub-class G4OpenGLXmViewer.
462 XFlush (dpy);
463 }
464}
465
466void G4OpenGLXViewer::print() {
467
468 //using namespace std;
469 //cout << "print_col_callback requested with file name: " << print_string << G4endl;
470
471 if (vectored_ps) {
472
473 G4OpenGLViewer::print();
474
475 } else {
476
477 XVisualInfo* pvi;
478 GLXContext pcx = create_GL_print_context(pvi);
479
480 if (!pcx) {
481 G4cout << "Unable to create print context." << G4endl;
482 return;
483 }
484
485 GLXContext tmp_cx;
486 tmp_cx = cx;
487 cx=pcx;
488
489 Pixmap pmap = XCreatePixmap (dpy,
490 XRootWindow (dpy, pvi->screen),
491 WinSize_x, WinSize_y,
492 pvi->depth);
493
494 GLXPixmap glxpmap = glXCreateGLXPixmap (dpy,
495 pvi,
496 pmap);
497
498 GLXDrawable tmp_win;
499 tmp_win=win;
500 win=glxpmap;
501
502 glXMakeCurrent (dpy,
503 win,
504 cx);
505
506 glViewport (0, 0, WinSize_x, WinSize_y);
507
508 ClearView ();
509 SetView ();
510 DrawView ();
511
512 generateEPS (print_string,
513 print_colour,
514 WinSize_x, WinSize_y);
515
516 win=tmp_win;
517 cx=tmp_cx;
518
519 glXMakeCurrent (dpy,
520 win,
521 cx);
522
523 }
524
525}
526
527GLubyte* G4OpenGLXViewer::grabPixels (int inColor, unsigned int width, unsigned int height) {
528
529 GLubyte* buffer;
530 GLint swapbytes, lsbfirst, rowlength;
531 GLint skiprows, skippixels, alignment;
532 GLenum format;
533 int size;
534
535 if (inColor) {
536 format = GL_RGB;
537 size = width*height*3;
538 } else {
539 format = GL_LUMINANCE;
540 size = width*height*1;
541 }
542
543 buffer = new GLubyte[size];
544 if (buffer == NULL)
545 return NULL;
546
547 glGetIntegerv (GL_UNPACK_SWAP_BYTES, &swapbytes);
548 glGetIntegerv (GL_UNPACK_LSB_FIRST, &lsbfirst);
549 glGetIntegerv (GL_UNPACK_ROW_LENGTH, &rowlength);
550
551 glGetIntegerv (GL_UNPACK_SKIP_ROWS, &skiprows);
552 glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &skippixels);
553 glGetIntegerv (GL_UNPACK_ALIGNMENT, &alignment);
554
555 glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
556 glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
557 glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
558
559 glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
560 glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
561 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
562
563 glReadPixels (0, 0, (GLsizei)width, (GLsizei)height, format, GL_UNSIGNED_BYTE, (GLvoid*) buffer);
564
565 glPixelStorei (GL_UNPACK_SWAP_BYTES, swapbytes);
566 glPixelStorei (GL_UNPACK_LSB_FIRST, lsbfirst);
567 glPixelStorei (GL_UNPACK_ROW_LENGTH, rowlength);
568
569 glPixelStorei (GL_UNPACK_SKIP_ROWS, skiprows);
570 glPixelStorei (GL_UNPACK_SKIP_PIXELS, skippixels);
571 glPixelStorei (GL_UNPACK_ALIGNMENT, alignment);
572
573 return buffer;
574}
575
576int G4OpenGLXViewer::generateEPS (char* filnam,
577 int inColour,
578 unsigned int width,
579 unsigned int height) {
580
581 FILE* fp;
582 GLubyte* pixels;
583 GLubyte* curpix;
584 int components, pos, i;
585
586 pixels = grabPixels (inColour, width, height);
587
588 if (pixels == NULL)
589 return 1;
590 if (inColour) {
591 components = 3;
592 } else {
593 components = 1;
594 }
595
596 fp = fopen (filnam, "w");
597 if (fp == NULL) {
598 return 2;
599 }
600
601 fprintf (fp, "%%!PS-Adobe-2.0 EPSF-1.2\n");
602 fprintf (fp, "%%%%Title: %s\n", filnam);
603 fprintf (fp, "%%%%Creator: OpenGL pixmap render output\n");
604 fprintf (fp, "%%%%BoundingBox: 0 0 %d %d\n", width, height);
605 fprintf (fp, "%%%%EndComments\n");
606 fprintf (fp, "gsave\n");
607 fprintf (fp, "/bwproc {\n");
608 fprintf (fp, " rgbproc\n");
609 fprintf (fp, " dup length 3 idiv string 0 3 0 \n");
610 fprintf (fp, " 5 -1 roll {\n");
611 fprintf (fp, " add 2 1 roll 1 sub dup 0 eq\n");
612 fprintf (fp, " { pop 3 idiv 3 -1 roll dup 4 -1 roll dup\n");
613 fprintf (fp, " 3 1 roll 5 -1 roll } put 1 add 3 0 \n");
614 fprintf (fp, " { 2 1 roll } ifelse\n");
615 fprintf (fp, " }forall\n");
616 fprintf (fp, " pop pop pop\n");
617 fprintf (fp, "} def\n");
618 fprintf (fp, "systemdict /colorimage known not {\n");
619 fprintf (fp, " /colorimage {\n");
620 fprintf (fp, " pop\n");
621 fprintf (fp, " pop\n");
622 fprintf (fp, " /rgbproc exch def\n");
623 fprintf (fp, " { bwproc } image\n");
624 fprintf (fp, " } def\n");
625 fprintf (fp, "} if\n");
626 fprintf (fp, "/picstr %d string def\n", width * components);
627 fprintf (fp, "%d %d scale\n", width, height);
628 fprintf (fp, "%d %d %d\n", width, height, 8);
629 fprintf (fp, "[%d 0 0 %d 0 0]\n", width, height);
630 fprintf (fp, "{currentfile picstr readhexstring pop}\n");
631 fprintf (fp, "false %d\n", components);
632 fprintf (fp, "colorimage\n");
633
634 curpix = (GLubyte*) pixels;
635 pos = 0;
636 for (i = width*height*components; i>0; i--) {
637 fprintf (fp, "%02hx ", *(curpix++));
638 if (++pos >= 32) {
639 fprintf (fp, "\n");
640 pos = 0;
641 }
642 }
643 if (pos)
644 fprintf (fp, "\n");
645
646 fprintf (fp, "grestore\n");
647 fprintf (fp, "showpage\n");
648 delete pixels;
649 fclose (fp);
650 return 0;
651}
652
653GLXContext G4OpenGLXViewer::create_GL_print_context(XVisualInfo*& pvi) {
654
655 pvi = glXChooseVisual (dpy,
656 XDefaultScreen (dpy),
657 snglBuf_RGBA);
658
659 if (!pvi) {
660 pvi = glXChooseVisual (dpy,
661 XDefaultScreen (dpy),
662 dblBuf_RGBA);
663 }
664
665 return glXCreateContext (dpy,
666 pvi,
667 NULL,
668 False);
669}
670
671#endif
Note: See TracBrowser for help on using the repository browser.