0025442: Visualization, TKOpenGl - prevent inclusion of system header glxext.h
[occt.git] / src / OpenGl / OpenGl_Window.cxx
1 // Created on: 2011-09-20
2 // Created by: Sergey ZERCHANINOV
3 // Copyright (c) 2011-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <OpenGl_GlCore12.hxx>
17
18 #include <InterfaceGraphic.hxx>
19
20 #include <OpenGl_Window.hxx>
21
22 #include <OpenGl_Context.hxx>
23 #include <OpenGl_GraphicDriver.hxx>
24
25 #include <Aspect_GraphicDeviceDefinitionError.hxx>
26 #include <TCollection_AsciiString.hxx>
27 #include <TCollection_ExtendedString.hxx>
28
29 #if defined(HAVE_EGL) || defined(__ANDROID__)
30   #include <EGL/egl.h>
31 #endif
32
33 IMPLEMENT_STANDARD_HANDLE(OpenGl_Window,MMgt_TShared)
34 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Window,MMgt_TShared)
35
36 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
37
38 namespace
39 {
40   static const TEL_COLOUR THE_DEFAULT_BG_COLOR = { { 0.F, 0.F, 0.F, 1.F } };
41
42 #if defined(HAVE_EGL) || defined(__ANDROID__)
43   //
44 #elif defined(_WIN32)
45
46   // WGL_ARB_pixel_format
47 #ifndef WGL_NUMBER_PIXEL_FORMATS_ARB
48   #define WGL_NUMBER_PIXEL_FORMATS_ARB            0x2000
49   #define WGL_DRAW_TO_WINDOW_ARB                  0x2001
50   #define WGL_DRAW_TO_BITMAP_ARB                  0x2002
51   #define WGL_ACCELERATION_ARB                    0x2003
52   #define WGL_NEED_PALETTE_ARB                    0x2004
53   #define WGL_NEED_SYSTEM_PALETTE_ARB             0x2005
54   #define WGL_SWAP_LAYER_BUFFERS_ARB              0x2006
55   #define WGL_SWAP_METHOD_ARB                     0x2007
56   #define WGL_NUMBER_OVERLAYS_ARB                 0x2008
57   #define WGL_NUMBER_UNDERLAYS_ARB                0x2009
58   #define WGL_TRANSPARENT_ARB                     0x200A
59   #define WGL_TRANSPARENT_RED_VALUE_ARB           0x2037
60   #define WGL_TRANSPARENT_GREEN_VALUE_ARB         0x2038
61   #define WGL_TRANSPARENT_BLUE_VALUE_ARB          0x2039
62   #define WGL_TRANSPARENT_ALPHA_VALUE_ARB         0x203A
63   #define WGL_TRANSPARENT_INDEX_VALUE_ARB         0x203B
64   #define WGL_SHARE_DEPTH_ARB                     0x200C
65   #define WGL_SHARE_STENCIL_ARB                   0x200D
66   #define WGL_SHARE_ACCUM_ARB                     0x200E
67   #define WGL_SUPPORT_GDI_ARB                     0x200F
68   #define WGL_SUPPORT_OPENGL_ARB                  0x2010
69   #define WGL_DOUBLE_BUFFER_ARB                   0x2011
70   #define WGL_STEREO_ARB                          0x2012
71   #define WGL_PIXEL_TYPE_ARB                      0x2013
72   #define WGL_COLOR_BITS_ARB                      0x2014
73   #define WGL_RED_BITS_ARB                        0x2015
74   #define WGL_RED_SHIFT_ARB                       0x2016
75   #define WGL_GREEN_BITS_ARB                      0x2017
76   #define WGL_GREEN_SHIFT_ARB                     0x2018
77   #define WGL_BLUE_BITS_ARB                       0x2019
78   #define WGL_BLUE_SHIFT_ARB                      0x201A
79   #define WGL_ALPHA_BITS_ARB                      0x201B
80   #define WGL_ALPHA_SHIFT_ARB                     0x201C
81   #define WGL_ACCUM_BITS_ARB                      0x201D
82   #define WGL_ACCUM_RED_BITS_ARB                  0x201E
83   #define WGL_ACCUM_GREEN_BITS_ARB                0x201F
84   #define WGL_ACCUM_BLUE_BITS_ARB                 0x2020
85   #define WGL_ACCUM_ALPHA_BITS_ARB                0x2021
86   #define WGL_DEPTH_BITS_ARB                      0x2022
87   #define WGL_STENCIL_BITS_ARB                    0x2023
88   #define WGL_AUX_BUFFERS_ARB                     0x2024
89
90   #define WGL_NO_ACCELERATION_ARB                 0x2025
91   #define WGL_GENERIC_ACCELERATION_ARB            0x2026
92   #define WGL_FULL_ACCELERATION_ARB               0x2027
93
94   #define WGL_SWAP_EXCHANGE_ARB                   0x2028
95   #define WGL_SWAP_COPY_ARB                       0x2029
96   #define WGL_SWAP_UNDEFINED_ARB                  0x202A
97
98   #define WGL_TYPE_RGBA_ARB                       0x202B
99   #define WGL_TYPE_COLORINDEX_ARB                 0x202C
100 #endif // WGL_NUMBER_PIXEL_FORMATS_ARB
101
102   // WGL_ARB_create_context_profile
103 #ifndef WGL_CONTEXT_MAJOR_VERSION_ARB
104   #define WGL_CONTEXT_MAJOR_VERSION_ARB           0x2091
105   #define WGL_CONTEXT_MINOR_VERSION_ARB           0x2092
106   #define WGL_CONTEXT_LAYER_PLANE_ARB             0x2093
107   #define WGL_CONTEXT_FLAGS_ARB                   0x2094
108   #define WGL_CONTEXT_PROFILE_MASK_ARB            0x9126
109
110   // WGL_CONTEXT_FLAGS bits
111   #define WGL_CONTEXT_DEBUG_BIT_ARB               0x0001
112   #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB  0x0002
113
114   // WGL_CONTEXT_PROFILE_MASK_ARB bits
115   #define WGL_CONTEXT_CORE_PROFILE_BIT_ARB          0x00000001
116   #define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
117 #endif // WGL_CONTEXT_MAJOR_VERSION_ARB
118
119   static LRESULT CALLBACK wndProcDummy (HWND theWin, UINT theMsg, WPARAM theParamW, LPARAM theParamL)
120   {
121     return DefWindowProcW (theWin, theMsg, theParamW, theParamL);
122   }
123 #else
124   static Bool WaitForNotify (Display* theDisp, XEvent* theEv, char* theArg)
125   {
126     return (theEv->type == MapNotify) && (theEv->xmap.window == (Window )theArg);
127   }
128 #endif
129
130 }
131
132 // =======================================================================
133 // function : OpenGl_Window
134 // purpose  :
135 // =======================================================================
136 OpenGl_Window::OpenGl_Window (const Handle(OpenGl_GraphicDriver)& theDriver,
137                               const CALL_DEF_WINDOW&        theCWindow,
138                               Aspect_RenderingContext       theGContext,
139                               const Handle(OpenGl_Caps)&    theCaps,
140                               const Handle(OpenGl_Context)& theShareCtx)
141 : myGlContext (new OpenGl_Context (theCaps)),
142   myOwnGContext (theGContext == 0),
143   myWidth ((Standard_Integer )theCWindow.dx),
144   myHeight ((Standard_Integer )theCWindow.dy),
145   myBgColor (THE_DEFAULT_BG_COLOR)
146 {
147   myBgColor.rgb[0] = theCWindow.Background.r;
148   myBgColor.rgb[1] = theCWindow.Background.g;
149   myBgColor.rgb[2] = theCWindow.Background.b;
150
151 #if defined(HAVE_EGL) || defined(__ANDROID__)
152   EGLDisplay anEglDisplay = (EGLDisplay )theDriver->getRawGlDisplay();
153   EGLContext anEglContext = (EGLContext )theDriver->getRawGlContext();
154   EGLConfig  anEglConfig  = (EGLConfig  )theDriver->getRawGlConfig();
155   if (anEglDisplay == EGL_NO_DISPLAY
156    || anEglContext == EGL_NO_CONTEXT
157    || anEglConfig == NULL)
158   {
159     Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window, EGL does not provide compatible configurations!");
160     return;
161   }
162
163   EGLSurface anEglSurf = EGL_NO_SURFACE;
164   if (theGContext == (EGLContext )EGL_NO_CONTEXT)
165   {
166     // create new surface
167     anEglSurf = eglCreateWindowSurface (anEglDisplay, anEglConfig, (EGLNativeWindowType )theCWindow.XWindow, NULL);
168     if (anEglSurf == EGL_NO_SURFACE)
169     {
170       Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window, EGL is unable to create surface for window!");
171       return;
172     }
173   }
174   else if (theGContext != anEglContext)
175   {
176     Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window, EGL is used in unsupported combination!");
177     return;
178   }
179   else
180   {
181     anEglSurf = eglGetCurrentSurface(EGL_DRAW);
182     if (anEglSurf == EGL_NO_SURFACE)
183     {
184       Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window, EGL is unable to retrieve current surface!");
185       return;
186     }
187   }
188
189   myGlContext->Init ((Aspect_Drawable )anEglSurf, (Aspect_Display )anEglDisplay, (Aspect_RenderingContext )anEglContext);
190 #elif defined(_WIN32)
191   (void )theDriver;
192   HWND  aWindow   = (HWND )theCWindow.XWindow;
193   HDC   aWindowDC = GetDC (aWindow);
194   HGLRC aGContext = (HGLRC )theGContext;
195
196   PIXELFORMATDESCRIPTOR aPixelFrmt;
197   memset (&aPixelFrmt, 0, sizeof(aPixelFrmt));
198   aPixelFrmt.nSize        = sizeof(PIXELFORMATDESCRIPTOR);
199   aPixelFrmt.nVersion     = 1;
200   aPixelFrmt.dwFlags      = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
201   aPixelFrmt.iPixelType   = PFD_TYPE_RGBA;
202   aPixelFrmt.cColorBits   = 24;
203   aPixelFrmt.cDepthBits   = 24;
204   aPixelFrmt.cStencilBits = 8;
205   aPixelFrmt.iLayerType   = PFD_MAIN_PLANE;
206   if (theCaps->contextStereo)
207   {
208     aPixelFrmt.dwFlags |= PFD_STEREO;
209   }
210
211   int aPixelFrmtId = ChoosePixelFormat (aWindowDC, &aPixelFrmt);
212
213   // in case of failure try without stereo if any
214   if (aPixelFrmtId == 0 && theCaps->contextStereo)
215   {
216     TCollection_ExtendedString aMsg ("OpenGl_Window::CreateWindow: "
217                                      "ChoosePixelFormat is unable to find stereo supported pixel format. "
218                                      "Choosing similar non stereo format.");
219     myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
220                               GL_DEBUG_TYPE_OTHER_ARB,
221                               0, GL_DEBUG_SEVERITY_HIGH_ARB, aMsg);
222
223     aPixelFrmt.dwFlags &= ~PFD_STEREO;
224     aPixelFrmtId = ChoosePixelFormat (aWindowDC, &aPixelFrmt);
225   }
226
227   if (aPixelFrmtId == 0)
228   {
229     ReleaseDC (aWindow, aWindowDC);
230
231     TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: ChoosePixelFormat failed. Error code: ");
232     aMsg += (int )GetLastError();
233     Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
234     return;
235   }
236
237   DescribePixelFormat (aWindowDC, aPixelFrmtId, sizeof(aPixelFrmt), &aPixelFrmt);
238
239   HGLRC aSlaveCtx = !theShareCtx.IsNull() ? (HGLRC )theShareCtx->myGContext : NULL;
240   if (aGContext == NULL)
241   {
242     // create temporary context to retrieve advanced context creation procedures
243     HMODULE aModule = GetModuleHandleW(NULL);
244     WNDCLASSW aClass; memset (&aClass, 0, sizeof(aClass));
245     aClass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
246     aClass.lpfnWndProc   = wndProcDummy;
247     aClass.hInstance     = aModule;
248     aClass.lpszClassName = L"OpenGl_WindowTmp";
249     HWND  aWinTmp     = NULL;
250     HDC   aDevCtxTmp  = NULL;
251     HGLRC aRendCtxTmp = NULL;
252     if ((!theCaps->contextDebug && !theCaps->contextNoAccel)
253      || RegisterClassW (&aClass) == 0)
254     {
255       aClass.lpszClassName = NULL;
256     }
257     if (aClass.lpszClassName != NULL)
258     {
259       DWORD anExStyle = WS_EX_TOOLWINDOW | WS_EX_WINDOWEDGE;
260     #if (_WIN32_WINNT >= 0x0500)
261       anExStyle |= WS_EX_NOACTIVATE;
262     #endif
263       aWinTmp = CreateWindowExW(anExStyle,
264                                 aClass.lpszClassName, L"OpenGl_WindowTmp",
265                                 WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_DISABLED,
266                                 2, 2, 4, 4,
267                                 NULL, NULL, aModule, NULL);
268     }
269     if (aWinTmp != NULL)
270     {
271       aDevCtxTmp = GetDC (aWinTmp);
272       SetPixelFormat (aDevCtxTmp, aPixelFrmtId, &aPixelFrmt);
273       aRendCtxTmp = wglCreateContext (aDevCtxTmp);
274     }
275
276     typedef BOOL (WINAPI *wglChoosePixelFormatARB_t)(HDC           theDevCtx,
277                                                      const int*    theIntAttribs,
278                                                      const float*  theFloatAttribs,
279                                                      unsigned int  theMaxFormats,
280                                                      int*          theFormatsOut,
281                                                      unsigned int* theNumFormatsOut);
282     typedef HGLRC (WINAPI *wglCreateContextAttribsARB_t)(HDC        theDevCtx,
283                                                          HGLRC      theShareContext,
284                                                          const int* theAttribs);
285     wglChoosePixelFormatARB_t    aChoosePixProc = NULL;
286     wglCreateContextAttribsARB_t aCreateCtxProc = NULL;
287     if (aRendCtxTmp != NULL)
288     {
289       wglMakeCurrent (aDevCtxTmp, aRendCtxTmp);
290
291       typedef const char* (WINAPI *wglGetExtensionsStringARB_t)(HDC theDeviceContext);
292       wglGetExtensionsStringARB_t aGetExtensions = (wglGetExtensionsStringARB_t  )wglGetProcAddress ("wglGetExtensionsStringARB");
293       const char* aWglExts = (aGetExtensions != NULL) ? aGetExtensions (wglGetCurrentDC()) : NULL;
294       if (OpenGl_Context::CheckExtension (aWglExts, "WGL_ARB_pixel_format"))
295       {
296         aChoosePixProc = (wglChoosePixelFormatARB_t    )wglGetProcAddress ("wglChoosePixelFormatARB");
297       }
298       if (OpenGl_Context::CheckExtension (aWglExts, "WGL_ARB_create_context_profile"))
299       {
300         aCreateCtxProc = (wglCreateContextAttribsARB_t )wglGetProcAddress ("wglCreateContextAttribsARB");
301       }
302     }
303
304     // choose extended pixel format
305     if (aChoosePixProc != NULL)
306     {
307       const int aPixAttribs[] =
308       {
309         WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
310         WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
311         WGL_DOUBLE_BUFFER_ARB,  GL_TRUE,
312         WGL_STEREO_ARB,         theCaps->contextStereo ? GL_TRUE : GL_FALSE,
313         WGL_PIXEL_TYPE_ARB,     WGL_TYPE_RGBA_ARB,
314         //WGL_SAMPLE_BUFFERS_ARB, 1,
315         //WGL_SAMPLES_ARB,        8,
316         WGL_COLOR_BITS_ARB,     24,
317         WGL_DEPTH_BITS_ARB,     24,
318         WGL_STENCIL_BITS_ARB,   8,
319         WGL_ACCELERATION_ARB,   theCaps->contextNoAccel ? WGL_NO_ACCELERATION_ARB : WGL_FULL_ACCELERATION_ARB,
320         0, 0,
321       };
322       unsigned int aFrmtsNb = 0;
323       aChoosePixProc (aWindowDC, aPixAttribs, NULL, 1, &aPixelFrmtId, &aFrmtsNb);
324     }
325
326     // setup pixel format - may be set only once per window
327     if (!SetPixelFormat (aWindowDC, aPixelFrmtId, &aPixelFrmt))
328     {
329       ReleaseDC (aWindow, aWindowDC);
330
331       TCollection_AsciiString aMsg("OpenGl_Window::CreateWindow: SetPixelFormat failed. Error code: ");
332       aMsg += (int )GetLastError();
333       Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
334       return;
335     }
336
337     // create GL context with extra options
338     if (aCreateCtxProc != NULL)
339     {
340       // Beware! NVIDIA drivers reject context creation when WGL_CONTEXT_PROFILE_MASK_ARB are specified
341       // but not WGL_CONTEXT_MAJOR_VERSION_ARB/WGL_CONTEXT_MINOR_VERSION_ARB.
342       int aCtxAttribs[] =
343       {
344         //WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
345         //WGL_CONTEXT_MINOR_VERSION_ARB, 2,
346         //WGL_CONTEXT_PROFILE_MASK_ARB,  WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, //WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
347         WGL_CONTEXT_FLAGS_ARB,         theCaps->contextDebug ? WGL_CONTEXT_DEBUG_BIT_ARB : 0,
348         0, 0
349       };
350
351       aGContext = aCreateCtxProc (aWindowDC, aSlaveCtx, aCtxAttribs);
352       if (aGContext != NULL)
353       {
354         aSlaveCtx = NULL;
355       }
356     }
357
358     if (aRendCtxTmp != NULL)
359     {
360       wglDeleteContext (aRendCtxTmp);
361     }
362     if (aDevCtxTmp != NULL)
363     {
364       ReleaseDC (aWinTmp, aDevCtxTmp);
365     }
366     if (aWinTmp != NULL)
367     {
368       DestroyWindow (aWinTmp);
369     }
370     if (aClass.lpszClassName != NULL)
371     {
372       UnregisterClassW (aClass.lpszClassName, aModule);
373     }
374
375     if (aGContext == NULL)
376     {
377       // create context using obsolete functionality
378       aGContext = wglCreateContext (aWindowDC);
379     }
380     if (aGContext == NULL)
381     {
382       ReleaseDC (aWindow, aWindowDC);
383
384       TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: wglCreateContext failed. Error code: ");
385       aMsg += (int )GetLastError();
386       Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
387       return;
388     }
389   }
390
391   // all GL context within one OpenGl_GraphicDriver should be shared!
392   if (aSlaveCtx != NULL && wglShareLists (aSlaveCtx, aGContext) != TRUE)
393   {
394     TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: wglShareLists failed. Error code: ");
395     aMsg += (int )GetLastError();
396     Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString());
397     return;
398   }
399
400   myGlContext->Init ((Aspect_Handle )aWindow, (Aspect_Handle )aWindowDC, (Aspect_RenderingContext )aGContext);
401 #else
402   Window aParent = (Window )theCWindow.XWindow;
403   Window aWindow = 0;
404
405   Display*   aDisp     = theDriver->GetDisplayConnection()->GetDisplay();
406   GLXContext aGContext = (GLXContext )theGContext;
407
408   XWindowAttributes wattr;
409   XGetWindowAttributes (aDisp, aParent, &wattr);
410   const int scr = DefaultScreen (aDisp);
411
412   XVisualInfo* aVis = NULL;
413   {
414     unsigned long aVisInfoMask = VisualIDMask | VisualScreenMask;
415     XVisualInfo aVisInfo;
416     aVisInfo.visualid = wattr.visual->visualid;
417     aVisInfo.screen   = scr;
418     int aNbItems;
419     aVis = XGetVisualInfo (aDisp, aVisInfoMask, &aVisInfo, &aNbItems);
420   }
421
422   if (!myOwnGContext)
423   {
424     if (aVis != NULL)
425     {
426       Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window::CreateWindow: XGetVisualInfo failed.");
427       return;
428     }
429
430     aWindow = aParent;
431   }
432   else
433   {
434   #if defined(__linux) || defined(Linux) || defined(__APPLE__)
435     if (aVis != NULL)
436     {
437       // check Visual for OpenGl context's parameters compability
438       int isGl = 0, isDoubleBuffer = 0, isRGBA = 0, isStereo = 0;
439       int aDepthSize = 0, aStencilSize = 0;
440
441       if (glXGetConfig (aDisp, aVis, GLX_USE_GL, &isGl) != 0)
442         isGl = 0;
443
444       if (glXGetConfig (aDisp, aVis, GLX_RGBA, &isRGBA) != 0)
445         isRGBA = 0;
446
447       if (glXGetConfig (aDisp, aVis, GLX_DOUBLEBUFFER, &isDoubleBuffer) != 0)
448         isDoubleBuffer = 0;
449
450       if (glXGetConfig (aDisp, aVis, GLX_STEREO, &isStereo) != 0)
451         isStereo = 0;
452
453       if (glXGetConfig (aDisp, aVis, GLX_DEPTH_SIZE, &aDepthSize) != 0)
454         aDepthSize = 0;
455
456       if (glXGetConfig (aDisp, aVis, GLX_STENCIL_SIZE, &aStencilSize) != 0)
457         aStencilSize = 0;
458
459       if (!isGl || !aDepthSize || !isRGBA  || !aStencilSize ||
460           (isDoubleBuffer ? 1 : 0) != 1 ||
461           (isStereo       ? 1 : 0) != (theCaps->contextStereo ? 1 : 0))
462       {
463         XFree (aVis);
464         aVis = NULL;
465       }
466     }
467   #endif
468
469     if (aVis == NULL)
470     {
471       int anIter = 0;
472       int anAttribs[13];
473       anAttribs[anIter++] = GLX_RGBA;
474
475       anAttribs[anIter++] = GLX_DEPTH_SIZE;
476       anAttribs[anIter++] = 1;
477
478       anAttribs[anIter++] = GLX_STENCIL_SIZE;
479       anAttribs[anIter++] = 1;
480
481       anAttribs[anIter++] = GLX_RED_SIZE;
482       anAttribs[anIter++] = (wattr.depth <= 8) ? 0 : 1;
483
484       anAttribs[anIter++] = GLX_GREEN_SIZE;
485       anAttribs[anIter++] = (wattr.depth <= 8) ? 0 : 1;
486
487       anAttribs[anIter++] = GLX_BLUE_SIZE;
488       anAttribs[anIter++] = (wattr.depth <= 8) ? 0 : 1;
489
490       anAttribs[anIter++] = GLX_DOUBLEBUFFER;
491
492       // warning: this flag may be set to None, so it need to be last in anAttribs
493       Standard_Integer aStereoFlagPos = anIter;
494       if (theCaps->contextStereo)
495         anAttribs[anIter++] = GLX_STEREO;
496
497       anAttribs[anIter++] = None;
498
499       aVis = glXChooseVisual (aDisp, scr, anAttribs);
500
501       // in case of failure try without stereo if any
502       if (aVis == NULL && theCaps->contextStereo)
503       {
504         TCollection_ExtendedString aMsg ("OpenGl_Window::CreateWindow: "
505                                          "glXChooseVisual is unable to find stereo supported pixel format. "
506                                          "Choosing similar non stereo format.");
507         myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
508                                   GL_DEBUG_TYPE_OTHER_ARB,
509                                   0, GL_DEBUG_SEVERITY_HIGH_ARB, aMsg);
510
511         anAttribs[aStereoFlagPos] = None;
512         aVis = glXChooseVisual (aDisp, scr, anAttribs);
513       }
514
515       if (aVis == NULL)
516       {
517         Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window::CreateWindow: glXChooseVisual failed.");
518         return;
519       }
520     }
521
522     if (!theShareCtx.IsNull())
523     {
524       // ctx est une copie du previous
525       aGContext = glXCreateContext (aDisp, aVis, (GLXContext )theShareCtx->myGContext, GL_TRUE);
526     }
527     else
528     {
529       aGContext = glXCreateContext (aDisp, aVis, NULL, GL_TRUE);
530     }
531
532     if (!aGContext)
533     {
534       Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window::CreateWindow: glXCreateContext failed.");
535       return;
536     }
537
538     Colormap cmap = XCreateColormap (aDisp, aParent, aVis->visual, AllocNone);
539
540     XColor color;
541     color.red   = (unsigned short) (myBgColor.rgb[0] * 0xFFFF);
542     color.green = (unsigned short) (myBgColor.rgb[1] * 0xFFFF);
543     color.blue  = (unsigned short) (myBgColor.rgb[2] * 0xFFFF);
544     color.flags = DoRed | DoGreen | DoBlue;
545     XAllocColor (aDisp, cmap, &color);
546
547     XSetWindowAttributes cwa;
548     cwa.colormap         = cmap;
549     cwa.event_mask       = StructureNotifyMask;
550     cwa.border_pixel     = color.pixel;
551     cwa.background_pixel = color.pixel;
552
553     if (aVis->visualid == wattr.visual->visualid)
554     {
555       aWindow = aParent;
556     }
557     else
558     {
559       unsigned long mask = CWBackPixel | CWColormap | CWBorderPixel | CWEventMask;
560       aWindow = XCreateWindow (aDisp, aParent, 0, 0, myWidth, myHeight, 0/*bw*/, aVis->depth, InputOutput, aVis->visual, mask, &cwa);
561     }
562
563     XSetWindowBackground (aDisp, aWindow, cwa.background_pixel);
564     XClearWindow (aDisp, aWindow);
565
566     if (aWindow != aParent)
567     {
568       XEvent anEvent;
569       XMapWindow (aDisp, aWindow);
570       XIfEvent (aDisp, &anEvent, WaitForNotify, (char* )aWindow);
571     }
572   }
573
574   myGlContext->Init ((Aspect_Drawable )aWindow, (Aspect_Display )aDisp, (Aspect_RenderingContext )aGContext);
575 #endif
576   myGlContext->Share (theShareCtx);
577
578   Init();
579 }
580
581 // =======================================================================
582 // function : ~OpenGl_Window
583 // purpose  :
584 // =======================================================================
585 OpenGl_Window::~OpenGl_Window()
586 {
587   if (!myOwnGContext
588    ||  myGlContext.IsNull())
589   {
590     myGlContext.Nullify();
591     return;
592   }
593
594   // release "GL" context if it is owned by window
595   // Mesa implementation can fail to destroy GL context if it set for current thread.
596   // It should be safer to unset thread GL context before its destruction.
597 #if defined(HAVE_EGL) || defined(__ANDROID__)
598   if ((EGLSurface )myGlContext->myWindow != EGL_NO_SURFACE)
599   {
600     eglDestroySurface ((EGLDisplay )myGlContext->myDisplay,
601                        (EGLSurface )myGlContext->myWindow);
602   }
603 #elif defined(_WIN32)
604   HWND  aWindow          = (HWND  )myGlContext->myWindow;
605   HDC   aWindowDC        = (HDC   )myGlContext->myWindowDC;
606   HGLRC aWindowGContext  = (HGLRC )myGlContext->myGContext;
607   HGLRC aThreadGContext  = wglGetCurrentContext();
608   myGlContext.Nullify();
609
610   if (aThreadGContext != NULL)
611   {
612     if (aThreadGContext == aWindowGContext)
613     {
614       wglMakeCurrent (NULL, NULL);
615     }
616
617     wglDeleteContext (aWindowGContext);
618   }
619   ReleaseDC (aWindow, aWindowDC);
620 #else
621   Display*    aDisplay        = (Display*    )myGlContext->myDisplay;
622   GLXContext  aWindowGContext = (GLXContext  )myGlContext->myGContext;
623   GLXContext  aThreadGContext = glXGetCurrentContext();
624   myGlContext.Nullify();
625
626   if (aDisplay != NULL)
627   {
628     if (aThreadGContext == aWindowGContext)
629     {
630       glXMakeCurrent (aDisplay, None, NULL);
631     }
632
633     // FSXXX sync necessary if non-direct rendering
634     glXWaitGL();
635     glXDestroyContext (aDisplay, aWindowGContext);
636   }
637 #endif
638 }
639
640 #endif // !__APPLE__
641
642 // =======================================================================
643 // function : Activate
644 // purpose  :
645 // =======================================================================
646 Standard_Boolean OpenGl_Window::Activate()
647 {
648   return myGlContext->MakeCurrent();
649 }
650
651 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
652
653 // =======================================================================
654 // function : Resize
655 // purpose  : call_subr_resize
656 // =======================================================================
657 void OpenGl_Window::Resize (const CALL_DEF_WINDOW& theCWindow)
658 {
659 #if !defined(_WIN32) && !defined(HAVE_EGL) && !defined(__ANDROID__)
660   Display* aDisp = (Display* )myGlContext->myDisplay;
661   if (aDisp == NULL)
662     return;
663 #endif
664
665   // If the size is not changed - do nothing
666   if ((myWidth == theCWindow.dx) && (myHeight == theCWindow.dy))
667     return;
668
669   myWidth  = (Standard_Integer )theCWindow.dx;
670   myHeight = (Standard_Integer )theCWindow.dy;
671
672 #if !defined(_WIN32) && !defined(HAVE_EGL) && !defined(__ANDROID__)
673   XResizeWindow (aDisp, myGlContext->myWindow, (unsigned int )myWidth, (unsigned int )myHeight);
674   XSync (aDisp, False);
675 #endif
676
677   Init();
678 }
679
680 #endif // !__APPLE__
681
682 // =======================================================================
683 // function : ReadDepths
684 // purpose  : TelReadDepths
685 // =======================================================================
686 void OpenGl_Window::ReadDepths (const Standard_Integer theX,     const Standard_Integer theY,
687                                 const Standard_Integer theWidth, const Standard_Integer theHeight,
688                                 float* theDepths)
689 {
690   if (theDepths == NULL || !Activate())
691     return;
692
693 #if !defined(GL_ES_VERSION_2_0)
694   glMatrixMode (GL_PROJECTION);
695   glLoadIdentity();
696   gluOrtho2D (0.0, (GLdouble )myWidth, 0.0, (GLdouble )myHeight);
697   glMatrixMode (GL_MODELVIEW);
698   glLoadIdentity();
699
700   glRasterPos2i (theX, theY);
701   DisableFeatures();
702   glReadPixels (theX, theY, theWidth, theHeight, GL_DEPTH_COMPONENT, GL_FLOAT, theDepths);
703   EnableFeatures();
704 #endif
705 }
706
707 // =======================================================================
708 // function : SetBackgroundColor
709 // purpose  : call_subr_set_background
710 // =======================================================================
711 void OpenGl_Window::SetBackgroundColor (const Standard_ShortReal theR,
712                                         const Standard_ShortReal theG,
713                                         const Standard_ShortReal theB)
714 {
715   myBgColor.rgb[0] = theR;
716   myBgColor.rgb[1] = theG;
717   myBgColor.rgb[2] = theB;
718 }
719
720 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
721
722 // =======================================================================
723 // function : Init
724 // purpose  :
725 // =======================================================================
726 void OpenGl_Window::Init()
727 {
728   if (!Activate())
729     return;
730
731 #if defined(HAVE_EGL) || defined(__ANDROID__)
732  eglQuerySurface ((EGLDisplay )myGlContext->myDisplay, (EGLSurface )myGlContext->myWindow, EGL_WIDTH,  &myWidth);
733  eglQuerySurface ((EGLDisplay )myGlContext->myDisplay, (EGLSurface )myGlContext->myWindow, EGL_HEIGHT, &myHeight);
734 #elif defined(_WIN32)
735   RECT cr;
736   GetClientRect ((HWND )myGlContext->myWindow, &cr);
737   myWidth  = cr.right - cr.left;
738   myHeight = cr.bottom - cr.top;
739 #else
740   Window aRootWin;
741   int aDummy;
742   unsigned int aDummyU;
743   unsigned int aNewWidth  = 0;
744   unsigned int aNewHeight = 0;
745   Display* aDisp = (Display* )myGlContext->myDisplay;
746   XGetGeometry (aDisp, myGlContext->myWindow, &aRootWin, &aDummy, &aDummy, &aNewWidth, &aNewHeight, &aDummyU, &aDummyU);
747   myWidth  = aNewWidth;
748   myHeight = aNewHeight;
749 #endif
750
751   glDisable (GL_SCISSOR_TEST);
752 #if !defined(GL_ES_VERSION_2_0)
753   glMatrixMode (GL_MODELVIEW);
754   glViewport (0, 0, myWidth, myHeight);
755   glDrawBuffer (GL_BACK);
756 #endif
757 }
758
759 #endif // !__APPLE__
760
761 // =======================================================================
762 // function : EnableFeatures
763 // purpose  :
764 // =======================================================================
765 void OpenGl_Window::EnableFeatures() const
766 {
767   //
768 }
769
770 // =======================================================================
771 // function : DisableFeatures
772 // purpose  :
773 // =======================================================================
774 void OpenGl_Window::DisableFeatures() const
775 {
776 #if !defined(GL_ES_VERSION_2_0)
777   glPixelTransferi (GL_MAP_COLOR, GL_FALSE);
778 #endif
779
780   /*
781   * Disable stuff that's likely to slow down glDrawPixels.
782   * (Omit as much of this as possible, when you know in advance
783   * that the OpenGL state will already be set correctly.)
784   */
785   glDisable(GL_BLEND);
786   glDisable(GL_DEPTH_TEST);
787   glDisable(GL_TEXTURE_2D);
788   glDisable(GL_STENCIL_TEST);
789
790 #if !defined(GL_ES_VERSION_2_0)
791   glDisable(GL_LIGHTING);
792   glDisable(GL_ALPHA_TEST);
793   glDisable(GL_FOG);
794   glDisable(GL_LOGIC_OP);
795   glDisable(GL_TEXTURE_1D);
796
797   glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
798   glPixelTransferi(GL_RED_SCALE, 1);
799   glPixelTransferi(GL_RED_BIAS, 0);
800   glPixelTransferi(GL_GREEN_SCALE, 1);
801   glPixelTransferi(GL_GREEN_BIAS, 0);
802   glPixelTransferi(GL_BLUE_SCALE, 1);
803   glPixelTransferi(GL_BLUE_BIAS, 0);
804   glPixelTransferi(GL_ALPHA_SCALE, 1);
805   glPixelTransferi(GL_ALPHA_BIAS, 0);
806
807   /*
808   * Disable extensions that could slow down glDrawPixels.
809   * (Actually, you should check for the presence of the proper
810   * extension before making these calls.  I've omitted that
811   * code for simplicity.)
812   */
813
814   if ((myGlContext->myGlVerMajor >= 1) && (myGlContext->myGlVerMinor >= 2))
815   {
816 #ifdef GL_EXT_convolution
817     if (myGlContext->CheckExtension ("GL_CONVOLUTION_1D_EXT"))
818       glDisable(GL_CONVOLUTION_1D_EXT);
819
820     if (myGlContext->CheckExtension ("GL_CONVOLUTION_2D_EXT"))
821       glDisable(GL_CONVOLUTION_2D_EXT);
822
823     if (myGlContext->CheckExtension ("GL_SEPARABLE_2D_EXT"))
824       glDisable(GL_SEPARABLE_2D_EXT);
825 #endif
826
827 #ifdef GL_EXT_histogram
828     if (myGlContext->CheckExtension ("GL_SEPARABLE_2D_EXT"))
829       glDisable(GL_HISTOGRAM_EXT);
830
831     if (myGlContext->CheckExtension ("GL_MINMAX_EXT"))
832       glDisable(GL_MINMAX_EXT);
833 #endif
834
835 #ifdef GL_EXT_texture3D
836     if (myGlContext->CheckExtension ("GL_TEXTURE_3D_EXT"))
837       glDisable(GL_TEXTURE_3D_EXT);
838 #endif
839   }
840 #endif
841 }
842
843 // =======================================================================
844 // function : MakeFrontBufCurrent
845 // purpose  : TelMakeFrontBufCurrent
846 // =======================================================================
847 void OpenGl_Window::MakeFrontBufCurrent() const
848 {
849 #if !defined(GL_ES_VERSION_2_0)
850   glDrawBuffer (GL_FRONT);
851 #endif
852 }
853
854 // =======================================================================
855 // function : MakeBackBufCurrent
856 // purpose  : TelMakeBackBufCurrent
857 // =======================================================================
858 void OpenGl_Window::MakeBackBufCurrent() const
859 {
860 #if !defined(GL_ES_VERSION_2_0)
861   glDrawBuffer (GL_BACK);
862 #endif
863 }