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