1 // Created on: 2011-10-20
2 // Created by: Sergey ZERCHANINOV
3 // Copyright (c) 2011-2013 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 #if defined(_WIN32)
17 #include <windows.h>
18 #endif
19
20 #include <OpenGl_GraphicDriver.hxx>
21 #include <OpenGl_Context.hxx>
22 #include <OpenGl_Flipper.hxx>
23 #include <OpenGl_GraduatedTrihedron.hxx>
24 #include <OpenGl_Group.hxx>
25 #include <OpenGl_View.hxx>
26 #include <OpenGl_StencilTest.hxx>
27 #include <OpenGl_Text.hxx>
28 #include <OpenGl_Window.hxx>
29 #include <OpenGl_Workspace.hxx>
30
31 #include <Aspect_GraphicDeviceDefinitionError.hxx>
32 #include <Aspect_IdentDefinitionError.hxx>
33 #include <Graphic3d_StructureManager.hxx>
34 #include <Message_Messenger.hxx>
35 #include <OSD_Environment.hxx>
36 #include <Standard_NotImplemented.hxx>
37
38 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_GraphicDriver,Graphic3d_GraphicDriver)
39
40 #if defined(_WIN32)
41 #include <WNT_Window.hxx>
42 #elif defined(HAVE_XLIB)
43 #include <Xw_Window.hxx>
44 #elif defined(__APPLE__)
45 #include <Cocoa_Window.hxx>
46 #else
47 #include <Aspect_NeutralWindow.hxx>
48 #endif
49
50 #if !defined(_WIN32) && !defined(__ANDROID__) && !defined(__QNX__) && !defined(__EMSCRIPTEN__) && (!defined(__APPLE__) || defined(HAVE_XLIB))
51 #include <X11/Xlib.h> // XOpenDisplay()
52 #include <GL/glx.h>
53 #endif
54
55 #if defined(HAVE_EGL) || defined(HAVE_GLES2) || defined(OCCT_UWP) || defined(__ANDROID__) || defined(__QNX__) || defined(__EMSCRIPTEN__)
56 #include <EGL/egl.h>
57 #ifndef EGL_OPENGL_ES3_BIT
58 #define EGL_OPENGL_ES3_BIT 0x00000040
59 #endif
60 #endif
61
62 namespace
63 {
64 static const Handle(OpenGl_Context) TheNullGlCtx;
65
66 #if defined(HAVE_EGL) || defined(HAVE_GLES2) || defined(OCCT_UWP) || defined(__ANDROID__) || defined(__QNX__) || defined(__EMSCRIPTEN__)
67 //! Wrapper over eglChooseConfig() called with preferred defaults.
chooseEglSurfConfig(EGLDisplay theDisplay)68 static EGLConfig chooseEglSurfConfig (EGLDisplay theDisplay)
69 {
70 EGLint aConfigAttribs[] =
71 {
72 EGL_RED_SIZE, 8,
73 EGL_GREEN_SIZE, 8,
74 EGL_BLUE_SIZE, 8,
75 EGL_ALPHA_SIZE, 0,
76 EGL_DEPTH_SIZE, 24,
77 EGL_STENCIL_SIZE, 8,
78 #if defined(GL_ES_VERSION_2_0)
79 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
80 #else
81 EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
82 #endif
83 EGL_NONE
84 };
85
86 EGLConfig aCfg = NULL;
87 EGLint aNbConfigs = 0;
88 for (Standard_Integer aGlesVer = 3; aGlesVer >= 2; --aGlesVer)
89 {
90 #if defined(GL_ES_VERSION_2_0)
91 aConfigAttribs[6 * 2 + 1] = aGlesVer == 3 ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_ES2_BIT;
92 #else
93 if (aGlesVer == 2)
94 {
95 break;
96 }
97 #endif
98
99 if (eglChooseConfig (theDisplay, aConfigAttribs, &aCfg, 1, &aNbConfigs) == EGL_TRUE
100 && aCfg != NULL)
101 {
102 return aCfg;
103 }
104 eglGetError();
105
106 aConfigAttribs[4 * 2 + 1] = 16; // try config with smaller depth buffer
107 if (eglChooseConfig (theDisplay, aConfigAttribs, &aCfg, 1, &aNbConfigs) == EGL_TRUE
108 && aCfg != NULL)
109 {
110 return aCfg;
111 }
112 eglGetError();
113 }
114 return aCfg;
115 }
116 #elif defined(HAVE_XLIB)
117 //! Search for RGBA double-buffered visual with stencil buffer.
118 static int TheDoubleBuffVisual[] =
119 {
120 GLX_RGBA,
121 GLX_DEPTH_SIZE, 16,
122 GLX_STENCIL_SIZE, 1,
123 GLX_DOUBLEBUFFER,
124 None
125 };
126
127 //! Search for RGBA double-buffered visual with stencil buffer.
128 static int TheDoubleBuffFBConfig[] =
129 {
130 GLX_X_RENDERABLE, True,
131 GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
132 GLX_RENDER_TYPE, GLX_RGBA_BIT,
133 GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
134 GLX_DEPTH_SIZE, 16,
135 GLX_STENCIL_SIZE, 1,
136 GLX_DOUBLEBUFFER, True,
137 None
138 };
139 #endif
140
141 }
142
143 // =======================================================================
144 // function : OpenGl_GraphicDriver
145 // purpose :
146 // =======================================================================
OpenGl_GraphicDriver(const Handle (Aspect_DisplayConnection)& theDisp,const Standard_Boolean theToInitialize)147 OpenGl_GraphicDriver::OpenGl_GraphicDriver (const Handle(Aspect_DisplayConnection)& theDisp,
148 const Standard_Boolean theToInitialize)
149 : Graphic3d_GraphicDriver (theDisp),
150 myIsOwnContext (Standard_False),
151 myEglDisplay (NULL),
152 myEglContext (NULL),
153 myEglConfig (NULL),
154 myCaps (new OpenGl_Caps()),
155 myMapOfView (1, NCollection_BaseAllocator::CommonBaseAllocator()),
156 myMapOfStructure (1, NCollection_BaseAllocator::CommonBaseAllocator())
157 {
158 #if defined(HAVE_EGL) || defined(HAVE_GLES2) || defined(OCCT_UWP) || defined(__ANDROID__) || defined(__QNX__) || defined(__EMSCRIPTEN__)
159 myEglDisplay = (Aspect_Display )EGL_NO_DISPLAY;
160 myEglContext = (Aspect_RenderingContext )EGL_NO_CONTEXT;
161 #endif
162
163 #if defined(HAVE_XLIB)
164 if (myDisplayConnection.IsNull())
165 {
166 //throw Aspect_GraphicDeviceDefinitionError("OpenGl_GraphicDriver: cannot connect to X server!");
167 return;
168 }
169
170 Display* aDisplay = (Display* )myDisplayConnection->GetDisplayAspect();
171 Bool toSync = ::getenv ("CSF_GraphicSync") != NULL
172 || ::getenv ("CALL_SYNCHRO_X") != NULL;
173 XSynchronize (aDisplay, toSync);
174 #endif
175 if (theToInitialize
176 && !InitContext())
177 {
178 throw Aspect_GraphicDeviceDefinitionError("OpenGl_GraphicDriver: default context can not be initialized!");
179 }
180 }
181
182 // =======================================================================
183 // function : ~OpenGl_GraphicDriver
184 // purpose :
185 // =======================================================================
~OpenGl_GraphicDriver()186 OpenGl_GraphicDriver::~OpenGl_GraphicDriver()
187 {
188 ReleaseContext();
189 }
190
191 // =======================================================================
192 // function : ReleaseContext
193 // purpose :
194 // =======================================================================
ReleaseContext()195 void OpenGl_GraphicDriver::ReleaseContext()
196 {
197 Handle(OpenGl_Context) aCtxShared;
198 for (NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIter (myMapOfView);
199 aViewIter.More(); aViewIter.Next())
200 {
201 const Handle(OpenGl_View)& aView = aViewIter.Value();
202 const Handle(OpenGl_Window)& aWindow = aView->GlWindow();
203 if (aWindow.IsNull())
204 {
205 continue;
206 }
207
208 const Handle(OpenGl_Context)& aCtx = aWindow->GetGlContext();
209 if (aCtx->MakeCurrent()
210 && aCtxShared.IsNull())
211 {
212 aCtxShared = aCtx;
213 }
214 }
215
216 if (!aCtxShared.IsNull())
217 {
218 aCtxShared->MakeCurrent();
219 }
220 for (NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIter (myMapOfView);
221 aViewIter.More(); aViewIter.Next())
222 {
223 const Handle(OpenGl_View)& aView = aViewIter.Value();
224 aView->ReleaseGlResources (aCtxShared);
225 }
226
227 for (NCollection_DataMap<Standard_Integer, OpenGl_Structure*>::Iterator aStructIt (myMapOfStructure);
228 aStructIt.More (); aStructIt.Next())
229 {
230 OpenGl_Structure* aStruct = aStructIt.ChangeValue();
231 aStruct->ReleaseGlResources (aCtxShared);
232 }
233
234 const bool isDeviceLost = !myMapOfStructure.IsEmpty();
235 for (NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIter (myMapOfView);
236 aViewIter.More(); aViewIter.Next())
237 {
238 const Handle(OpenGl_View)& aView = aViewIter.Value();
239 if (isDeviceLost)
240 {
241 aView->StructureManager()->SetDeviceLost();
242 }
243
244 const Handle(OpenGl_Window)& aWindow = aView->GlWindow();
245 if (aWindow.IsNull())
246 {
247 continue;
248 }
249
250 aWindow->GetGlContext()->forcedRelease();
251 }
252
253 #if defined(HAVE_EGL) || defined(HAVE_GLES2) || defined(OCCT_UWP) || defined(__ANDROID__) || defined(__QNX__) || defined(__EMSCRIPTEN__)
254 if (myIsOwnContext)
255 {
256 if (myEglContext != (Aspect_RenderingContext )EGL_NO_CONTEXT)
257 {
258 if (eglMakeCurrent ((EGLDisplay )myEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT) != EGL_TRUE)
259 {
260 ::Message::SendWarning ("OpenGl_GraphicDriver, FAILED to release OpenGL context");
261 }
262 eglDestroyContext ((EGLDisplay )myEglDisplay, (EGLContext )myEglContext);
263 }
264
265 if (myEglDisplay != (Aspect_Display )EGL_NO_DISPLAY)
266 {
267 if (eglTerminate ((EGLDisplay )myEglDisplay) != EGL_TRUE)
268 {
269 ::Message::SendWarning ("OpenGl_GraphicDriver, EGL, eglTerminate FAILED");
270 }
271 }
272 }
273
274 myEglDisplay = (Aspect_Display )EGL_NO_DISPLAY;
275 myEglContext = (Aspect_RenderingContext )EGL_NO_CONTEXT;
276 myEglConfig = NULL;
277 #endif
278 myIsOwnContext = Standard_False;
279 }
280
281 // =======================================================================
282 // function : InitContext
283 // purpose :
284 // =======================================================================
InitContext()285 Standard_Boolean OpenGl_GraphicDriver::InitContext()
286 {
287 ReleaseContext();
288 #if defined(HAVE_EGL) || defined(HAVE_GLES2) || defined(OCCT_UWP) || defined(__ANDROID__) || defined(__QNX__) || defined(__EMSCRIPTEN__)
289
290 #if defined(HAVE_XLIB)
291 if (myDisplayConnection.IsNull())
292 {
293 return Standard_False;
294 }
295 Display* aDisplay = (Display* )myDisplayConnection->GetDisplayAspect();
296 myEglDisplay = (Aspect_Display )eglGetDisplay (aDisplay);
297 #else
298 myEglDisplay = (Aspect_Display )eglGetDisplay (EGL_DEFAULT_DISPLAY);
299 #endif
300 if ((EGLDisplay )myEglDisplay == EGL_NO_DISPLAY)
301 {
302 ::Message::SendFail ("Error: no EGL display");
303 return Standard_False;
304 }
305
306 EGLint aVerMajor = 0; EGLint aVerMinor = 0;
307 if (eglInitialize ((EGLDisplay )myEglDisplay, &aVerMajor, &aVerMinor) != EGL_TRUE)
308 {
309 ::Message::SendFail ("Error: EGL display is unavailable");
310 return Standard_False;
311 }
312
313 myEglConfig = chooseEglSurfConfig ((EGLDisplay )myEglDisplay);
314 if (myEglConfig == NULL)
315 {
316 ::Message::SendFail ("Error: EGL does not provide compatible configurations");
317 return Standard_False;
318 }
319
320 #if defined(GL_ES_VERSION_2_0)
321 EGLint anEglCtxAttribs3[] = { EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE, EGL_NONE };
322 EGLint anEglCtxAttribs2[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, EGL_NONE };
323 if (eglBindAPI (EGL_OPENGL_ES_API) != EGL_TRUE)
324 {
325 ::Message::SendFail ("Error: EGL does not provide OpenGL ES client");
326 return Standard_False;
327 }
328 if (myCaps->contextMajorVersionUpper != 2)
329 {
330 myEglContext = (Aspect_RenderingContext )eglCreateContext ((EGLDisplay )myEglDisplay, myEglConfig, EGL_NO_CONTEXT, anEglCtxAttribs3);
331 }
332 if ((EGLContext )myEglContext == EGL_NO_CONTEXT)
333 {
334 myEglContext = (Aspect_RenderingContext )eglCreateContext ((EGLDisplay )myEglDisplay, myEglConfig, EGL_NO_CONTEXT, anEglCtxAttribs2);
335 }
336 #else
337 EGLint* anEglCtxAttribs = NULL;
338 if (eglBindAPI (EGL_OPENGL_API) != EGL_TRUE)
339 {
340 ::Message::SendFail ("Error: EGL does not provide OpenGL client");
341 return Standard_False;
342 }
343 myEglContext = (Aspect_RenderingContext )eglCreateContext ((EGLDisplay )myEglDisplay, myEglConfig, EGL_NO_CONTEXT, anEglCtxAttribs);
344 #endif
345
346 if ((EGLContext )myEglContext == EGL_NO_CONTEXT)
347 {
348 ::Message::SendFail ("Error: EGL is unable to create OpenGL context");
349 return Standard_False;
350 }
351 // eglMakeCurrent() fails or even crash with EGL_NO_SURFACE on some implementations
352 //if (eglMakeCurrent ((EGLDisplay )myEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, (EGLContext )myEglContext) != EGL_TRUE)
353 //{
354 // ::Message::SendFail ("Error: EGL is unable bind OpenGL context");
355 // return Standard_False;
356 //}
357 #endif
358 chooseVisualInfo();
359 myIsOwnContext = Standard_True;
360 return Standard_True;
361 }
362
363 // =======================================================================
364 // function : InitEglContext
365 // purpose :
366 // =======================================================================
InitEglContext(Aspect_Display theEglDisplay,Aspect_RenderingContext theEglContext,void * theEglConfig)367 Standard_Boolean OpenGl_GraphicDriver::InitEglContext (Aspect_Display theEglDisplay,
368 Aspect_RenderingContext theEglContext,
369 void* theEglConfig)
370 {
371 ReleaseContext();
372 #if defined(HAVE_EGL) || defined(HAVE_GLES2) || defined(OCCT_UWP) || defined(__ANDROID__) || defined(__QNX__) || defined(__EMSCRIPTEN__)
373 #if defined(HAVE_XLIB)
374 if (myDisplayConnection.IsNull())
375 {
376 return Standard_False;
377 }
378 #endif
379
380 if ((EGLDisplay )theEglDisplay == EGL_NO_DISPLAY
381 || (EGLContext )theEglContext == EGL_NO_CONTEXT)
382 {
383 return Standard_False;
384 }
385 myEglDisplay = theEglDisplay;
386 myEglContext = theEglContext;
387 myEglConfig = theEglConfig;
388 if (theEglConfig == NULL)
389 {
390 myEglConfig = chooseEglSurfConfig ((EGLDisplay )myEglDisplay);
391 if (myEglConfig == NULL)
392 {
393 ::Message::SendFail ("Error: EGL does not provide compatible configurations");
394 return Standard_False;
395 }
396 }
397 chooseVisualInfo();
398 return Standard_True;
399 #else
400 (void )theEglDisplay;
401 (void )theEglContext;
402 (void )theEglConfig;
403 throw Standard_NotImplemented ("OpenGl_GraphicDriver::InitEglContext() is not implemented");
404 #endif
405 }
406
407 // =======================================================================
408 // function : chooseVisualInfo
409 // purpose :
410 // =======================================================================
chooseVisualInfo()411 void OpenGl_GraphicDriver::chooseVisualInfo()
412 {
413 if (myDisplayConnection.IsNull())
414 {
415 return;
416 }
417
418 #if defined(HAVE_XLIB)
419 Display* aDisp = (Display* )myDisplayConnection->GetDisplayAspect();
420
421 XVisualInfo* aVisInfo = NULL;
422 Aspect_FBConfig anFBConfig = NULL;
423 #if defined(HAVE_EGL) || defined(HAVE_GLES2)
424 XVisualInfo aVisInfoTmp;
425 memset (&aVisInfoTmp, 0, sizeof(aVisInfoTmp));
426 aVisInfoTmp.screen = DefaultScreen (aDisp);
427 if (myEglDisplay != EGL_NO_DISPLAY
428 && myEglConfig != NULL
429 && eglGetConfigAttrib ((EGLDisplay )myEglDisplay, myEglConfig, EGL_NATIVE_VISUAL_ID, (EGLint* )&aVisInfoTmp.visualid) == EGL_TRUE)
430 {
431 int aNbVisuals = 0;
432 aVisInfo = XGetVisualInfo (aDisp, VisualIDMask | VisualScreenMask, &aVisInfoTmp, &aNbVisuals);
433 }
434 #else
435 int aScreen = DefaultScreen(aDisp);
436 int aDummy = 0;
437 if (!XQueryExtension (aDisp, "GLX", &aDummy, &aDummy, &aDummy)
438 || !glXQueryExtension (aDisp, &aDummy, &aDummy))
439 {
440 Message::SendFail ("Error: OpenGl_GraphicDriver, GLX extension is unavailable");
441 }
442
443 // FBConfigs were added in GLX version 1.3
444 int aGlxMajor = 0, aGlxMinor = 0;
445 const bool hasFBCfg = glXQueryVersion (aDisp, &aGlxMajor, &aGlxMinor)
446 && ((aGlxMajor == 1 && aGlxMinor >= 3) || (aGlxMajor > 1));
447 if (hasFBCfg)
448 {
449 int aFBCount = 0;
450 GLXFBConfig* aFBCfgList = NULL;
451 if (hasFBCfg)
452 {
453 aFBCfgList = glXChooseFBConfig (aDisp, aScreen, TheDoubleBuffFBConfig, &aFBCount);
454 }
455 if(aFBCfgList != NULL
456 && aFBCount >= 1)
457 {
458 anFBConfig = aFBCfgList[0];
459 aVisInfo = glXGetVisualFromFBConfig (aDisp, anFBConfig);
460
461 /*int aDepthSize = 0, aStencilSize = 0;
462 glXGetFBConfigAttrib (aDisp, anFBConfig, GLX_DEPTH_SIZE, &aDepthSize);
463 glXGetFBConfigAttrib (aDisp, anFBConfig, GLX_STENCIL_SIZE, &aStencilSize);
464 Message::SendInfo() << "GLX FBConfig:"
465 << "\n DepthSize= " << aDepthSize
466 << "\n StencilSize= " << aStencilSize;*/
467 }
468 XFree (aFBCfgList);
469 }
470
471 if (aVisInfo == NULL)
472 {
473 aVisInfo = glXChooseVisual (aDisp, aScreen, TheDoubleBuffVisual);
474 }
475 #endif
476 if (aVisInfo != NULL)
477 {
478 myDisplayConnection->SetDefaultVisualInfo ((Aspect_XVisualInfo* )aVisInfo, anFBConfig);
479 }
480 else
481 {
482 Message::SendWarning ("OpenGl_GraphicDriver, couldn't find compatible Visual (RGBA, double-buffered)");
483 }
484 #endif
485 }
486
487 // =======================================================================
488 // function : InquireLimit
489 // purpose :
490 // =======================================================================
InquireLimit(const Graphic3d_TypeOfLimit theType) const491 Standard_Integer OpenGl_GraphicDriver::InquireLimit (const Graphic3d_TypeOfLimit theType) const
492 {
493 const Handle(OpenGl_Context)& aCtx = GetSharedContext();
494 switch (theType)
495 {
496 case Graphic3d_TypeOfLimit_MaxNbLights:
497 return Graphic3d_ShaderProgram::THE_MAX_LIGHTS_DEFAULT;
498 case Graphic3d_TypeOfLimit_MaxNbClipPlanes:
499 return !aCtx.IsNull() ? aCtx->MaxClipPlanes() : 0;
500 case Graphic3d_TypeOfLimit_MaxNbViews:
501 return 10000;
502 case Graphic3d_TypeOfLimit_MaxTextureSize:
503 return !aCtx.IsNull() ? aCtx->MaxTextureSize() : 1024;
504 case Graphic3d_TypeOfLimit_MaxCombinedTextureUnits:
505 return !aCtx.IsNull() ? aCtx->MaxCombinedTextureUnits() : 1;
506 case Graphic3d_TypeOfLimit_MaxMsaa:
507 return !aCtx.IsNull() ? aCtx->MaxMsaaSamples() : 0;
508 case Graphic3d_TypeOfLimit_MaxViewDumpSizeX:
509 return !aCtx.IsNull() ? aCtx->MaxDumpSizeX() : 1024;
510 case Graphic3d_TypeOfLimit_MaxViewDumpSizeY:
511 return !aCtx.IsNull() ? aCtx->MaxDumpSizeY() : 1024;
512 case Graphic3d_TypeOfLimit_HasPBR:
513 return (!aCtx.IsNull() && aCtx->HasPBR()) ? 1 : 0;
514 case Graphic3d_TypeOfLimit_HasRayTracing:
515 return (!aCtx.IsNull() && aCtx->HasRayTracing()) ? 1 : 0;
516 case Graphic3d_TypeOfLimit_HasRayTracingTextures:
517 return (!aCtx.IsNull() && aCtx->HasRayTracingTextures()) ? 1 : 0;
518 case Graphic3d_TypeOfLimit_HasRayTracingAdaptiveSampling:
519 return (!aCtx.IsNull() && aCtx->HasRayTracingAdaptiveSampling()) ? 1 : 0;
520 case Graphic3d_TypeOfLimit_HasRayTracingAdaptiveSamplingAtomic:
521 return (!aCtx.IsNull() && aCtx->HasRayTracingAdaptiveSamplingAtomic()) ? 1 : 0;
522 case Graphic3d_TypeOfLimit_HasSRGB:
523 return (!aCtx.IsNull() && aCtx->HasSRGB()) ? 1 : 0;
524 case Graphic3d_TypeOfLimit_HasBlendedOit:
525 return (!aCtx.IsNull()
526 && aCtx->hasDrawBuffers != OpenGl_FeatureNotAvailable
527 && (aCtx->hasFloatBuffer != OpenGl_FeatureNotAvailable || aCtx->hasHalfFloatBuffer != OpenGl_FeatureNotAvailable)) ? 1 : 0;
528 case Graphic3d_TypeOfLimit_HasBlendedOitMsaa:
529 return (!aCtx.IsNull()
530 && aCtx->hasSampleVariables != OpenGl_FeatureNotAvailable
531 && (InquireLimit (Graphic3d_TypeOfLimit_HasBlendedOit) == 1)) ? 1 : 0;
532 case Graphic3d_TypeOfLimit_HasFlatShading:
533 return !aCtx.IsNull() && aCtx->hasFlatShading != OpenGl_FeatureNotAvailable ? 1 : 0;
534 case Graphic3d_TypeOfLimit_IsWorkaroundFBO:
535 return !aCtx.IsNull() && aCtx->MaxTextureSize() != aCtx->MaxDumpSizeX() ? 1 : 0;
536 case Graphic3d_TypeOfLimit_HasMeshEdges:
537 return !aCtx.IsNull() && aCtx->hasGeometryStage != OpenGl_FeatureNotAvailable ? 1 : 0;
538 case Graphic3d_TypeOfLimit_NB:
539 return 0;
540 }
541 return 0;
542 }
543
544 // =======================================================================
545 // function : DefaultTextHeight
546 // purpose :
547 // =======================================================================
DefaultTextHeight() const548 Standard_ShortReal OpenGl_GraphicDriver::DefaultTextHeight() const
549 {
550 return 16.;
551 }
552
553 // =======================================================================
554 // function : EnableVBO
555 // purpose :
556 // =======================================================================
EnableVBO(const Standard_Boolean theToTurnOn)557 void OpenGl_GraphicDriver::EnableVBO (const Standard_Boolean theToTurnOn)
558 {
559 myCaps->vboDisable = !theToTurnOn;
560 }
561
562 // =======================================================================
563 // function : IsVerticalSync
564 // purpose :
565 // =======================================================================
IsVerticalSync() const566 bool OpenGl_GraphicDriver::IsVerticalSync() const
567 {
568 return myCaps->swapInterval == 1;
569 }
570
571 // =======================================================================
572 // function : SetVerticalSync
573 // purpose :
574 // =======================================================================
SetVerticalSync(bool theToEnable)575 void OpenGl_GraphicDriver::SetVerticalSync (bool theToEnable)
576 {
577 myCaps->swapInterval = theToEnable ? 1 : 0;
578 }
579
580 // =======================================================================
581 // function : GetSharedContext
582 // purpose :
583 // =======================================================================
Handle(OpenGl_Context)584 const Handle(OpenGl_Context)& OpenGl_GraphicDriver::GetSharedContext (bool theBound) const
585 {
586 if (myMapOfView.IsEmpty())
587 {
588 return TheNullGlCtx;
589 }
590
591 for (NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIter (myMapOfView); aViewIter.More(); aViewIter.Next())
592 {
593 if (const Handle(OpenGl_Window)& aWindow = aViewIter.Value()->GlWindow())
594 {
595 if (!theBound)
596 {
597 return aWindow->GetGlContext();
598 }
599 else if (aWindow->GetGlContext()->IsCurrent())
600 {
601 return aWindow->GetGlContext();
602 }
603 }
604 }
605
606 return TheNullGlCtx;
607 }
608
609 // =======================================================================
610 // function : MemoryInfo
611 // purpose :
612 // =======================================================================
MemoryInfo(Standard_Size & theFreeBytes,TCollection_AsciiString & theInfo) const613 Standard_Boolean OpenGl_GraphicDriver::MemoryInfo (Standard_Size& theFreeBytes,
614 TCollection_AsciiString& theInfo) const
615 {
616 // this is extra work (for OpenGl_Context initialization)...
617 OpenGl_Context aGlCtx;
618 if (!aGlCtx.Init())
619 {
620 return Standard_False;
621 }
622 theFreeBytes = aGlCtx.AvailableMemory();
623 theInfo = aGlCtx.MemoryInfo();
624 return !theInfo.IsEmpty();
625 }
626
627 // =======================================================================
628 // function : SetBuffersNoSwap
629 // purpose :
630 // =======================================================================
SetBuffersNoSwap(const Standard_Boolean theIsNoSwap)631 void OpenGl_GraphicDriver::SetBuffersNoSwap (const Standard_Boolean theIsNoSwap)
632 {
633 myCaps->buffersNoSwap = theIsNoSwap;
634 }
635
636 // =======================================================================
637 // function : TextSize
638 // purpose :
639 // =======================================================================
TextSize(const Handle (Graphic3d_CView)& theView,const Standard_CString theText,const Standard_ShortReal theHeight,Standard_ShortReal & theWidth,Standard_ShortReal & theAscent,Standard_ShortReal & theDescent) const640 void OpenGl_GraphicDriver::TextSize (const Handle(Graphic3d_CView)& theView,
641 const Standard_CString theText,
642 const Standard_ShortReal theHeight,
643 Standard_ShortReal& theWidth,
644 Standard_ShortReal& theAscent,
645 Standard_ShortReal& theDescent) const
646 {
647 const Handle(OpenGl_Context)& aCtx = GetSharedContext();
648 if (aCtx.IsNull())
649 {
650 return;
651 }
652
653 const Standard_ShortReal aHeight = (theHeight < 2.0f) ? DefaultTextHeight() : theHeight;
654 OpenGl_Aspects aTextAspect;
655 TCollection_ExtendedString anExtText = theText;
656 NCollection_String aText (anExtText.ToExtString());
657 OpenGl_Text::StringSize (aCtx, aText, aTextAspect, aHeight,
658 theView->RenderingParams().Resolution, theView->RenderingParams().FontHinting,
659 theWidth, theAscent, theDescent);
660 }
661
662 //=======================================================================
663 //function : InsertLayerBefore
664 //purpose :
665 //=======================================================================
InsertLayerBefore(const Graphic3d_ZLayerId theLayerId,const Graphic3d_ZLayerSettings & theSettings,const Graphic3d_ZLayerId theLayerAfter)666 void OpenGl_GraphicDriver::InsertLayerBefore (const Graphic3d_ZLayerId theLayerId,
667 const Graphic3d_ZLayerSettings& theSettings,
668 const Graphic3d_ZLayerId theLayerAfter)
669 {
670 base_type::InsertLayerBefore (theLayerId, theSettings, theLayerAfter);
671
672 // Add layer to all views
673 for (NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIt (myMapOfView); aViewIt.More(); aViewIt.Next())
674 {
675 aViewIt.Value()->InsertLayerBefore (theLayerId, theSettings, theLayerAfter);
676 }
677 }
678
679 //=======================================================================
680 //function : InsertLayerAfter
681 //purpose :
682 //=======================================================================
InsertLayerAfter(const Graphic3d_ZLayerId theNewLayerId,const Graphic3d_ZLayerSettings & theSettings,const Graphic3d_ZLayerId theLayerBefore)683 void OpenGl_GraphicDriver::InsertLayerAfter (const Graphic3d_ZLayerId theNewLayerId,
684 const Graphic3d_ZLayerSettings& theSettings,
685 const Graphic3d_ZLayerId theLayerBefore)
686 {
687 base_type::InsertLayerAfter (theNewLayerId, theSettings, theLayerBefore);
688
689 // Add layer to all views
690 for (NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIt (myMapOfView); aViewIt.More(); aViewIt.Next())
691 {
692 aViewIt.Value()->InsertLayerAfter (theNewLayerId, theSettings, theLayerBefore);
693 }
694 }
695
696 //=======================================================================
697 //function : RemoveZLayer
698 //purpose :
699 //=======================================================================
RemoveZLayer(const Graphic3d_ZLayerId theLayerId)700 void OpenGl_GraphicDriver::RemoveZLayer (const Graphic3d_ZLayerId theLayerId)
701 {
702 base_type::RemoveZLayer (theLayerId);
703
704 // Remove layer from all of the views
705 for (NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIt (myMapOfView); aViewIt.More(); aViewIt.Next())
706 {
707 aViewIt.Value()->RemoveZLayer (theLayerId);
708 }
709
710 // Unset Z layer for all of the structures.
711 for (NCollection_DataMap<Standard_Integer, OpenGl_Structure*>::Iterator aStructIt (myMapOfStructure); aStructIt.More(); aStructIt.Next())
712 {
713 OpenGl_Structure* aStruct = aStructIt.ChangeValue ();
714 if (aStruct->ZLayer() == theLayerId)
715 aStruct->SetZLayer (Graphic3d_ZLayerId_Default);
716 }
717 }
718
719 //=======================================================================
720 //function : SetZLayerSettings
721 //purpose :
722 //=======================================================================
SetZLayerSettings(const Graphic3d_ZLayerId theLayerId,const Graphic3d_ZLayerSettings & theSettings)723 void OpenGl_GraphicDriver::SetZLayerSettings (const Graphic3d_ZLayerId theLayerId,
724 const Graphic3d_ZLayerSettings& theSettings)
725 {
726 base_type::SetZLayerSettings (theLayerId, theSettings);
727
728 // Change Z layer settings in all managed views
729 for (NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIt (myMapOfView); aViewIt.More(); aViewIt.Next())
730 {
731 aViewIt.Value()->SetZLayerSettings (theLayerId, theSettings);
732 }
733 }
734
735 // =======================================================================
736 // function : Structure
737 // purpose :
738 // =======================================================================
Handle(Graphic3d_CStructure)739 Handle(Graphic3d_CStructure) OpenGl_GraphicDriver::CreateStructure (const Handle(Graphic3d_StructureManager)& theManager)
740 {
741 Handle(OpenGl_Structure) aStructure = new OpenGl_Structure (theManager);
742 myMapOfStructure.Bind (aStructure->Id, aStructure.operator->());
743 return aStructure;
744 }
745
746 // =======================================================================
747 // function : Structure
748 // purpose :
749 // =======================================================================
RemoveStructure(Handle (Graphic3d_CStructure)& theCStructure)750 void OpenGl_GraphicDriver::RemoveStructure (Handle(Graphic3d_CStructure)& theCStructure)
751 {
752 OpenGl_Structure* aStructure = NULL;
753 if (!myMapOfStructure.Find (theCStructure->Id, aStructure))
754 {
755 return;
756 }
757
758 myMapOfStructure.UnBind (theCStructure->Id);
759 aStructure->Release (GetSharedContext());
760 theCStructure.Nullify();
761 }
762
763 // =======================================================================
764 // function : CreateView
765 // purpose :
766 // =======================================================================
Handle(Graphic3d_CView)767 Handle(Graphic3d_CView) OpenGl_GraphicDriver::CreateView (const Handle(Graphic3d_StructureManager)& theMgr)
768 {
769 Handle(OpenGl_View) aView = new OpenGl_View (theMgr, this, myCaps, &myStateCounter);
770 myMapOfView.Add (aView);
771 for (NCollection_List<Handle(Graphic3d_Layer)>::Iterator aLayerIter (myLayers); aLayerIter.More(); aLayerIter.Next())
772 {
773 const Handle(Graphic3d_Layer)& aLayer = aLayerIter.Value();
774 aView->InsertLayerAfter (aLayer->LayerId(), aLayer->LayerSettings(), Graphic3d_ZLayerId_UNKNOWN);
775 }
776 return aView;
777 }
778
779 // =======================================================================
780 // function : RemoveView
781 // purpose :
782 // =======================================================================
RemoveView(const Handle (Graphic3d_CView)& theView)783 void OpenGl_GraphicDriver::RemoveView (const Handle(Graphic3d_CView)& theView)
784 {
785 Handle(OpenGl_Context) aCtx = GetSharedContext();
786 Handle(OpenGl_View) aView = Handle(OpenGl_View)::DownCast (theView);
787 if (aView.IsNull())
788 {
789 return;
790 }
791
792 if (!myMapOfView.Remove (aView))
793 {
794 return;
795 }
796
797 Handle(OpenGl_Window) aWindow = aView->GlWindow();
798 if (!aWindow.IsNull()
799 && aWindow->GetGlContext()->MakeCurrent())
800 {
801 aCtx = aWindow->GetGlContext();
802 }
803 else
804 {
805 // try to hijack another context if any
806 const Handle(OpenGl_Context)& anOtherCtx = GetSharedContext();
807 if (!anOtherCtx.IsNull()
808 && anOtherCtx != aWindow->GetGlContext())
809 {
810 aCtx = anOtherCtx;
811 aCtx->MakeCurrent();
812 }
813 }
814
815 aView->ReleaseGlResources (aCtx);
816 if (myMapOfView.IsEmpty())
817 {
818 // The last view removed but some objects still present.
819 // Release GL resources now without object destruction.
820 for (NCollection_DataMap<Standard_Integer, OpenGl_Structure*>::Iterator aStructIt (myMapOfStructure);
821 aStructIt.More (); aStructIt.Next())
822 {
823 OpenGl_Structure* aStruct = aStructIt.ChangeValue();
824 aStruct->ReleaseGlResources (aCtx);
825 }
826
827 if (!myMapOfStructure.IsEmpty())
828 {
829 aView->StructureManager()->SetDeviceLost();
830 }
831 }
832 }
833
834 // =======================================================================
835 // function : Window
836 // purpose :
837 // =======================================================================
Handle(OpenGl_Window)838 Handle(OpenGl_Window) OpenGl_GraphicDriver::CreateRenderWindow (const Handle(Aspect_Window)& theWindow,
839 const Aspect_RenderingContext theContext)
840 {
841 Handle(OpenGl_Context) aShareCtx = GetSharedContext();
842 Handle(OpenGl_Window) aWindow = new OpenGl_Window (this, theWindow, theContext, myCaps, aShareCtx);
843 return aWindow;
844 }
845
846 //=======================================================================
847 //function : ViewExists
848 //purpose :
849 //=======================================================================
ViewExists(const Handle (Aspect_Window)& theWindow,Handle (Graphic3d_CView)& theView)850 Standard_Boolean OpenGl_GraphicDriver::ViewExists (const Handle(Aspect_Window)& theWindow,
851 Handle(Graphic3d_CView)& theView)
852 {
853 // Parse the list of views to find a view with the specified window
854 const Aspect_Drawable aNativeHandle = theWindow->NativeHandle();
855 for (NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIt (myMapOfView); aViewIt.More(); aViewIt.Next())
856 {
857 const Handle(OpenGl_View)& aView = aViewIt.Value();
858 if (!aView->IsDefined()
859 || !aView->IsActive())
860 {
861 continue;
862 }
863
864 const Handle(Aspect_Window) anAspectWindow = aView->Window();
865 const Aspect_Drawable aViewNativeHandle = anAspectWindow->NativeHandle();
866 if (aViewNativeHandle == aNativeHandle)
867 {
868 theView = aView;
869 return true;
870 }
871 }
872
873 return false;
874 }
875
876 //=======================================================================
877 //function : setDeviceLost
878 //purpose :
879 //=======================================================================
setDeviceLost()880 void OpenGl_GraphicDriver::setDeviceLost()
881 {
882 if (myMapOfStructure.IsEmpty())
883 {
884 return;
885 }
886
887 for (NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIter (myMapOfView); aViewIter.More(); aViewIter.Next())
888 {
889 const Handle(OpenGl_View)& aView = aViewIter.Value();
890 if (aView->myWasRedrawnGL)
891 {
892 aView->StructureManager()->SetDeviceLost();
893 }
894 }
895 }
896