0031668: Visualization - WebGL sample doesn't work on Emscripten 1.39
[occt.git] / src / OpenGl / OpenGl_Context.cxx
1 // Created on: 2012-01-26
2 // Created by: Kirill GAVRILOV
3 // Copyright (c) 2012-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 #if defined(_WIN32)
17   #include <windows.h>
18 #endif
19
20 #include <OpenGl_Context.hxx>
21
22 #include <OpenGl_ArbTBO.hxx>
23 #include <OpenGl_ArbIns.hxx>
24 #include <OpenGl_ArbDbg.hxx>
25 #include <OpenGl_ArbFBO.hxx>
26 #include <OpenGl_ExtGS.hxx>
27 #include <OpenGl_ArbSamplerObject.hxx>
28 #include <OpenGl_ArbTexBindless.hxx>
29 #include <OpenGl_GlCore45.hxx>
30 #include <OpenGl_FrameBuffer.hxx>
31 #include <OpenGl_FrameStats.hxx>
32 #include <OpenGl_Sampler.hxx>
33 #include <OpenGl_ShaderManager.hxx>
34 #include <OpenGl_TextureSetPairIterator.hxx>
35 #include <OpenGl_Workspace.hxx>
36 #include <OpenGl_Aspects.hxx>
37
38 #include <Graphic3d_TransformUtils.hxx>
39 #include <Graphic3d_RenderingParams.hxx>
40 #include <Image_SupportedFormats.hxx>
41 #include <Message_Messenger.hxx>
42 #include <NCollection_Vector.hxx>
43 #include <Standard_ProgramError.hxx>
44 #include <Standard_WarningDisableFunctionCast.hxx>
45
46 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Context,Standard_Transient)
47
48 #if defined(HAVE_EGL)
49   #include <EGL/egl.h>
50   #ifdef _MSC_VER
51     #pragma comment(lib, "libEGL.lib")
52   #endif
53 #elif defined(_WIN32)
54   //
55 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
56   #include <dlfcn.h>
57   #if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
58     //
59   #else
60     #include <OpenGL/OpenGL.h>
61     #include <CoreGraphics/CoreGraphics.h>
62   #endif
63 #else
64   #include <GL/glx.h> // glXGetProcAddress()
65 #endif
66
67 #ifdef __EMSCRIPTEN__
68   #include <emscripten.h>
69   #include <emscripten/html5.h>
70
71   //! Check if WebGL extension is available and activate it
72   //! (usage of extension without activation will generate errors).
73   static bool checkEnableWebGlExtension (const OpenGl_Context& theCtx,
74                                          const char* theExtName)
75   {
76     if (!theCtx.CheckExtension (theExtName))
77     {
78       return false;
79     }
80     if (EMSCRIPTEN_WEBGL_CONTEXT_HANDLE aWebGlCtx = emscripten_webgl_get_current_context())
81     {
82       if (emscripten_webgl_enable_extension (aWebGlCtx, theExtName))
83       {
84         return true;
85       }
86     }
87     return false;
88   }
89 #endif
90
91 namespace
92 {
93   static const Handle(OpenGl_Resource) NULL_GL_RESOURCE;
94   static const OpenGl_Mat4 THE_IDENTITY_MATRIX;
95
96   //! Add key-value pair to the dictionary.
97   static void addInfo (TColStd_IndexedDataMapOfStringString& theDict,
98                        const TCollection_AsciiString& theKey,
99                        const TCollection_AsciiString& theValue)
100   {
101     theDict.ChangeFromIndex (theDict.Add (theKey, theValue)) = theValue;
102   }
103
104   //! Add key-value pair to the dictionary.
105   static void addInfo (TColStd_IndexedDataMapOfStringString& theDict,
106                        const TCollection_AsciiString& theKey,
107                        const char* theValue)
108   {
109     TCollection_AsciiString aValue (theValue != NULL ? theValue : "");
110     theDict.ChangeFromIndex (theDict.Add (theKey, aValue)) = aValue;
111   }
112 }
113
114 // =======================================================================
115 // function : OpenGl_Context
116 // purpose  :
117 // =======================================================================
118 OpenGl_Context::OpenGl_Context (const Handle(OpenGl_Caps)& theCaps)
119 : core11     (NULL),
120   core11fwd  (NULL),
121   core15     (NULL),
122   core15fwd  (NULL),
123   core20     (NULL),
124   core20fwd  (NULL),
125   core30     (NULL),
126   core30fwd  (NULL),
127   core32     (NULL),
128   core32back (NULL),
129   core33     (NULL),
130   core33back (NULL),
131   core41     (NULL),
132   core41back (NULL),
133   core42     (NULL),
134   core42back (NULL),
135   core43     (NULL),
136   core43back (NULL),
137   core44     (NULL),
138   core44back (NULL),
139   core45     (NULL),
140   core45back (NULL),
141   caps   (!theCaps.IsNull() ? theCaps : new OpenGl_Caps()),
142   hasGetBufferData (Standard_False),
143 #if defined(GL_ES_VERSION_2_0)
144   hasHighp   (Standard_False),
145   hasUintIndex(Standard_False),
146   hasTexRGBA8(Standard_False),
147 #else
148   hasHighp   (Standard_True),
149   hasUintIndex(Standard_True),
150   hasTexRGBA8(Standard_True),
151 #endif
152   hasTexFloatLinear (Standard_False),
153   hasTexSRGB (Standard_False),
154   hasFboSRGB (Standard_False),
155   hasSRGBControl (Standard_False),
156 #if defined(GL_ES_VERSION_2_0)
157   hasFlatShading (OpenGl_FeatureNotAvailable),
158 #else
159   hasFlatShading (OpenGl_FeatureInCore),
160 #endif
161   hasGlslBitwiseOps  (OpenGl_FeatureNotAvailable),
162   hasDrawBuffers     (OpenGl_FeatureNotAvailable),
163   hasFloatBuffer     (OpenGl_FeatureNotAvailable),
164   hasHalfFloatBuffer (OpenGl_FeatureNotAvailable),
165   hasSampleVariables (OpenGl_FeatureNotAvailable),
166   hasGeometryStage   (OpenGl_FeatureNotAvailable),
167   arbDrawBuffers (Standard_False),
168   arbNPTW  (Standard_False),
169   arbTexRG (Standard_False),
170   arbTexFloat (Standard_False),
171   arbSamplerObject (NULL),
172   arbTexBindless (NULL),
173   arbTBO (NULL),
174   arbTboRGB32 (Standard_False),
175   arbIns (NULL),
176   arbDbg (NULL),
177   arbFBO (NULL),
178   arbFBOBlit (NULL),
179   arbSampleShading (Standard_False),
180   extFragDepth (Standard_False),
181   extDrawBuffers (Standard_False),
182   extGS  (NULL),
183   extBgra(Standard_False),
184   extAnis(Standard_False),
185   extPDS (Standard_False),
186   atiMem (Standard_False),
187   nvxMem (Standard_False),
188   oesSampleVariables (Standard_False),
189   oesStdDerivatives (Standard_False),
190   mySharedResources (new OpenGl_ResourcesMap()),
191   myDelayed         (new OpenGl_DelayReleaseMap()),
192   myUnusedResources (new OpenGl_ResourcesStack()),
193   myClippingState (),
194   myGlLibHandle (NULL),
195   myFuncs (new OpenGl_GlFunctions()),
196   mySupportedFormats (new Image_SupportedFormats()),
197   myAnisoMax   (1),
198   myTexClamp   (GL_CLAMP_TO_EDGE),
199   myMaxTexDim  (1024),
200   myMaxTexCombined (1),
201   myMaxTexUnitsFFP (1),
202   myMaxDumpSizeX (1024),
203   myMaxDumpSizeY (1024),
204   myMaxClipPlanes (6),
205   myMaxMsaaSamples(0),
206   myMaxDrawBuffers (1),
207   myMaxColorAttachments (1),
208   myGlVerMajor (0),
209   myGlVerMinor (0),
210   myIsInitialized (Standard_False),
211   myIsStereoBuffers (Standard_False),
212   myIsGlNormalizeEnabled (Standard_False),
213   mySpriteTexUnit (Graphic3d_TextureUnit_PointSprite),
214   myHasRayTracing (Standard_False),
215   myHasRayTracingTextures (Standard_False),
216   myHasRayTracingAdaptiveSampling (Standard_False),
217   myHasRayTracingAdaptiveSamplingAtomic (Standard_False),
218   myHasPBR (Standard_False),
219   myPBREnvLUTTexUnit       (Graphic3d_TextureUnit_PbrEnvironmentLUT),
220   myPBRDiffIBLMapSHTexUnit (Graphic3d_TextureUnit_PbrIblDiffuseSH),
221   myPBRSpecIBLMapTexUnit   (Graphic3d_TextureUnit_PbrIblSpecular),
222   myFrameStats (new OpenGl_FrameStats()),
223   myActiveMockTextures (0),
224 #if !defined(GL_ES_VERSION_2_0)
225   myPointSpriteOrig (GL_UPPER_LEFT),
226   myRenderMode (GL_RENDER),
227   myShadeModel (GL_SMOOTH),
228   myPolygonMode (GL_FILL),
229 #else
230   myPointSpriteOrig (0),
231   myRenderMode (0),
232   myShadeModel (0),
233   myPolygonMode (0),
234 #endif
235   myToCullBackFaces (false),
236   myReadBuffer (0),
237   myDrawBuffers (0, 7),
238   myDefaultVao (0),
239   myColorMask (true),
240   myAlphaToCoverage (false),
241   myIsGlDebugCtx (false),
242   myIsSRgbWindow (false),
243   myResolution (Graphic3d_RenderingParams::THE_DEFAULT_RESOLUTION),
244   myResolutionRatio (1.0f),
245   myLineWidthScale (1.0f),
246   myLineFeather (1.0f),
247   myRenderScale (1.0f),
248   myRenderScaleInv (1.0f)
249 {
250   myViewport[0] = 0;
251   myViewport[1] = 0;
252   myViewport[2] = 0;
253   myViewport[3] = 0;
254   myViewportVirt[0] = 0;
255   myViewportVirt[1] = 0;
256   myViewportVirt[2] = 0;
257   myViewportVirt[3] = 0;
258
259   myPolygonOffset.Mode   = Aspect_POM_Off;
260   myPolygonOffset.Factor = 0.0f;
261   myPolygonOffset.Units  = 0.0f;
262
263   // system-dependent fields
264 #if defined(HAVE_EGL)
265   myDisplay  = (Aspect_Display          )EGL_NO_DISPLAY;
266   myWindow   = (Aspect_Drawable         )EGL_NO_SURFACE;
267   myGContext = (Aspect_RenderingContext )EGL_NO_CONTEXT;
268 #elif defined(_WIN32)
269   myWindow   = NULL;
270   myWindowDC = NULL;
271   myGContext = NULL;
272 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
273   // Vendors can not extend functionality on this system
274   // and developers are limited to OpenGL support provided by Mac OS X SDK.
275   // We retrieve function pointers from system library
276   // to generalize extensions support on all platforms.
277   // In this way we also reach binary compatibility benefit between OS releases
278   // if some newest functionality is optionally used.
279   // Notice that GL version / extension availability checks are required
280   // because function pointers may be available but not functionality itself
281   // (depends on renderer).
282 #if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
283   myGContext    = NULL;
284   myGlLibHandle = dlopen ("/System/Library/Frameworks/OpenGLES.framework/OpenGLES", RTLD_LAZY);
285 #else
286   myGContext    = NULL;
287   myGlLibHandle = dlopen ("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);
288 #endif
289 #else
290   myDisplay =  NULL;
291   myWindow   = 0;
292   myGContext = 0;
293 #endif
294
295   memset (myFuncs.operator->(), 0, sizeof(OpenGl_GlFunctions));
296   myShaderManager = new OpenGl_ShaderManager (this);
297 }
298
299 // =======================================================================
300 // function : ~OpenGl_Context
301 // purpose  :
302 // =======================================================================
303 OpenGl_Context::~OpenGl_Context()
304 {
305   // release clean up queue
306   ReleaseDelayed();
307
308 #if !defined(GL_ES_VERSION_2_0)
309   // release default VAO
310   if (myDefaultVao != 0
311    && IsValid()
312    && core32 != NULL)
313   {
314     core32->glDeleteVertexArrays (1, &myDefaultVao);
315   }
316   myDefaultVao = 0;
317 #endif
318
319   // release mock textures
320   if (!myTextureRgbaBlack.IsNull())
321   {
322     myTextureRgbaBlack->Release (this);
323     myTextureRgbaBlack.Nullify();
324   }
325   if (!myTextureRgbaWhite.IsNull())
326   {
327     myTextureRgbaWhite->Release (this);
328     myTextureRgbaWhite.Nullify();
329   }
330
331   // release default FBO
332   if (!myDefaultFbo.IsNull())
333   {
334     myDefaultFbo->Release (this);
335     myDefaultFbo.Nullify();
336   }
337
338   // release shared resources if any
339   if (mySharedResources->GetRefCount() <= 1)
340   {
341     myShaderManager.Nullify();
342     for (NCollection_DataMap<TCollection_AsciiString, Handle(OpenGl_Resource)>::Iterator anIter (*mySharedResources);
343          anIter.More(); anIter.Next())
344     {
345       anIter.Value()->Release (this);
346     }
347
348     // release delayed resources added during deletion of shared resources
349     while (!myUnusedResources->IsEmpty())
350     {
351       myUnusedResources->First()->Release (this);
352       myUnusedResources->RemoveFirst();
353     }
354   }
355   else if (myShaderManager->IsSameContext (this))
356   {
357     myShaderManager->SetContext (NULL);
358   }
359   mySharedResources.Nullify();
360   myDelayed.Nullify();
361
362   if (arbDbg != NULL
363    && myIsGlDebugCtx
364    && IsValid())
365   {
366     // reset callback
367   #if !defined(GL_ES_VERSION_2_0)
368     void* aPtr = NULL;
369     glGetPointerv (GL_DEBUG_CALLBACK_USER_PARAM, &aPtr);
370     if (aPtr == this)
371   #endif
372     {
373       arbDbg->glDebugMessageCallback (NULL, NULL);
374     }
375     myIsGlDebugCtx = Standard_False;
376   }
377 }
378
379 // =======================================================================
380 // function : forcedRelease
381 // purpose  :
382 // =======================================================================
383 void OpenGl_Context::forcedRelease()
384 {
385   ReleaseDelayed();
386   for (NCollection_DataMap<TCollection_AsciiString, Handle(OpenGl_Resource)>::Iterator anIter (*mySharedResources);
387        anIter.More(); anIter.Next())
388   {
389     anIter.Value()->Release (this);
390   }
391   mySharedResources->Clear();
392   myShaderManager->clear();
393   myShaderManager->SetContext (NULL);
394
395   // release delayed resources added during deletion of shared resources
396   while (!myUnusedResources->IsEmpty())
397   {
398     myUnusedResources->First()->Release (this);
399     myUnusedResources->RemoveFirst();
400   }
401 }
402
403 // =======================================================================
404 // function : ResizeViewport
405 // purpose  :
406 // =======================================================================
407 void OpenGl_Context::ResizeViewport (const Standard_Integer* theRect)
408 {
409   core11fwd->glViewport (theRect[0], theRect[1], theRect[2], theRect[3]);
410   myViewport[0] = theRect[0];
411   myViewport[1] = theRect[1];
412   myViewport[2] = theRect[2];
413   myViewport[3] = theRect[3];
414   if (HasRenderScale())
415   {
416     myViewportVirt[0] = Standard_Integer(theRect[0] * myRenderScaleInv);
417     myViewportVirt[1] = Standard_Integer(theRect[1] * myRenderScaleInv);
418     myViewportVirt[2] = Standard_Integer(theRect[2] * myRenderScaleInv);
419     myViewportVirt[3] = Standard_Integer(theRect[3] * myRenderScaleInv);
420   }
421   else
422   {
423     myViewportVirt[0] = theRect[0];
424     myViewportVirt[1] = theRect[1];
425     myViewportVirt[2] = theRect[2];
426     myViewportVirt[3] = theRect[3];
427   }
428 }
429
430 #if !defined(GL_ES_VERSION_2_0)
431 inline Standard_Integer stereoToMonoBuffer (const Standard_Integer theBuffer)
432 {
433   switch (theBuffer)
434   {
435     case GL_BACK_LEFT:
436     case GL_BACK_RIGHT:
437       return GL_BACK;
438     case GL_FRONT_LEFT:
439     case GL_FRONT_RIGHT:
440       return GL_FRONT;
441     default:
442       return theBuffer;
443   }
444 }
445 #endif
446
447 // =======================================================================
448 // function : SetReadBuffer
449 // purpose  :
450 // =======================================================================
451 void OpenGl_Context::SetReadBuffer (const Standard_Integer theReadBuffer)
452 {
453 #if !defined(GL_ES_VERSION_2_0)
454   myReadBuffer = !myIsStereoBuffers ? stereoToMonoBuffer (theReadBuffer) : theReadBuffer;
455   if (myReadBuffer < GL_COLOR_ATTACHMENT0
456    && arbFBO != NULL)
457   {
458     arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, OpenGl_FrameBuffer::NO_FRAMEBUFFER);
459   }
460   ::glReadBuffer (myReadBuffer);
461 #else
462   (void )theReadBuffer;
463 #endif
464 }
465
466 // =======================================================================
467 // function : SetDrawBuffer
468 // purpose  :
469 // =======================================================================
470 void OpenGl_Context::SetDrawBuffer (const Standard_Integer theDrawBuffer)
471 {
472 #if !defined(GL_ES_VERSION_2_0)
473   const Standard_Integer aDrawBuffer = !myIsStereoBuffers ? stereoToMonoBuffer (theDrawBuffer) : theDrawBuffer;
474   if (aDrawBuffer < GL_COLOR_ATTACHMENT0
475    && arbFBO != NULL)
476   {
477     arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, OpenGl_FrameBuffer::NO_FRAMEBUFFER);
478   }
479   ::glDrawBuffer (aDrawBuffer);
480
481   myDrawBuffers.Init (GL_NONE);
482   myDrawBuffers.SetValue (0, aDrawBuffer);
483 #else
484   (void )theDrawBuffer;
485 #endif
486 }
487
488 // =======================================================================
489 // function : SetDrawBuffers
490 // purpose  :
491 // =======================================================================
492 void OpenGl_Context::SetDrawBuffers (const Standard_Integer theNb, const Standard_Integer* theDrawBuffers)
493 {
494   Standard_ASSERT_RETURN (hasDrawBuffers, "Multiple draw buffers feature is not supported by the context", Standard_ASSERT_DO_NOTHING());
495
496   if (myDrawBuffers.Length() < theNb)
497   {
498     // should actually never happen here
499     myDrawBuffers.Resize (0, theNb - 1, false);
500   }
501   myDrawBuffers.Init (GL_NONE);
502
503   Standard_Boolean useDefaultFbo = Standard_False;
504   for (Standard_Integer anI = 0; anI < theNb; ++anI)
505   {
506     if (theDrawBuffers[anI] < GL_COLOR_ATTACHMENT0 && theDrawBuffers[anI] != GL_NONE)
507     {
508       useDefaultFbo = Standard_True;
509     }
510     else
511     {
512       myDrawBuffers.SetValue (anI, theDrawBuffers[anI]);
513     }
514   }
515   if (arbFBO != NULL && useDefaultFbo)
516   {
517     arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, OpenGl_FrameBuffer::NO_FRAMEBUFFER);
518   }
519
520   myFuncs->glDrawBuffers (theNb, (const GLenum*)theDrawBuffers);
521 }
522
523 // =======================================================================
524 // function : SetFrameBufferSRGB
525 // purpose  :
526 // =======================================================================
527 void OpenGl_Context::SetFrameBufferSRGB (bool theIsFbo, bool theIsFboSRgb)
528 {
529   if (!hasFboSRGB)
530   {
531     myIsSRgbActive = false;
532     return;
533   }
534   myIsSRgbActive = ToRenderSRGB()
535                && (theIsFbo || myIsSRgbWindow)
536                && theIsFboSRgb;
537   if (!hasSRGBControl)
538   {
539     return;
540   }
541
542   if (myIsSRgbActive)
543   {
544     core11fwd->glEnable (GL_FRAMEBUFFER_SRGB);
545   }
546   else
547   {
548     core11fwd->glDisable (GL_FRAMEBUFFER_SRGB);
549   }
550 }
551
552 // =======================================================================
553 // function : SetCullBackFaces
554 // purpose  :
555 // =======================================================================
556 void OpenGl_Context::SetCullBackFaces (bool theToEnable)
557 {
558   if (myToCullBackFaces == theToEnable)
559   {
560     return;
561   }
562
563   myToCullBackFaces = theToEnable;
564   if (theToEnable)
565   {
566     //glCullFace (GL_BACK); GL_BACK by default
567     core11fwd->glEnable (GL_CULL_FACE);
568   }
569   else
570   {
571     core11fwd->glDisable (GL_CULL_FACE);
572   }
573 }
574
575 // =======================================================================
576 // function : FetchState
577 // purpose  :
578 // =======================================================================
579 void OpenGl_Context::FetchState()
580 {
581 #if !defined(GL_ES_VERSION_2_0)
582   // cache feedback mode state
583   if (core11 != NULL)
584   {
585     ::glGetIntegerv (GL_RENDER_MODE, &myRenderMode);
586     ::glGetIntegerv (GL_SHADE_MODEL, &myShadeModel);
587   }
588
589   // cache read buffers state
590   ::glGetIntegerv (GL_READ_BUFFER, &myReadBuffer);
591
592   // cache draw buffers state
593   if (myDrawBuffers.Length() < myMaxDrawBuffers)
594   {
595     myDrawBuffers.Resize (0, myMaxDrawBuffers - 1, false);
596   }
597   myDrawBuffers.Init (GL_NONE);
598
599   Standard_Integer aDrawBuffer = GL_NONE;
600   if (myMaxDrawBuffers == 1)
601   {
602     ::glGetIntegerv (GL_DRAW_BUFFER, &aDrawBuffer);
603     myDrawBuffers.SetValue (0, aDrawBuffer);
604   }
605   else
606   {
607     for (Standard_Integer anI = 0; anI < myMaxDrawBuffers; ++anI)
608     {
609       ::glGetIntegerv (GL_DRAW_BUFFER0 + anI, &aDrawBuffer);
610       myDrawBuffers.SetValue (anI, aDrawBuffer);
611     }
612   }
613 #endif
614 }
615
616 // =======================================================================
617 // function : Share
618 // purpose  :
619 // =======================================================================
620 void OpenGl_Context::Share (const Handle(OpenGl_Context)& theShareCtx)
621 {
622   if (!theShareCtx.IsNull())
623   {
624     mySharedResources = theShareCtx->mySharedResources;
625     myDelayed         = theShareCtx->myDelayed;
626     myUnusedResources = theShareCtx->myUnusedResources;
627     myShaderManager   = theShareCtx->myShaderManager;
628   }
629 }
630
631 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
632
633 // =======================================================================
634 // function : IsCurrent
635 // purpose  :
636 // =======================================================================
637 Standard_Boolean OpenGl_Context::IsCurrent() const
638 {
639 #if defined(HAVE_EGL)
640   if ((EGLDisplay )myDisplay  == EGL_NO_DISPLAY
641    || (EGLContext )myGContext == EGL_NO_CONTEXT)
642   {
643     return Standard_False;
644   }
645
646   return (((EGLDisplay )myDisplay  == eglGetCurrentDisplay())
647        && ((EGLContext )myGContext == eglGetCurrentContext())
648        && ((EGLSurface )myWindow   == eglGetCurrentSurface (EGL_DRAW)));
649 #elif defined(_WIN32)
650   if (myWindowDC == NULL || myGContext == NULL)
651   {
652     return Standard_False;
653   }
654   return (( (HDC )myWindowDC == wglGetCurrentDC())
655       && ((HGLRC )myGContext == wglGetCurrentContext()));
656 #else
657   if (myDisplay == NULL || myWindow == 0 || myGContext == 0)
658   {
659     return Standard_False;
660   }
661
662   return (   ((Display* )myDisplay  == glXGetCurrentDisplay())
663        &&  ((GLXContext )myGContext == glXGetCurrentContext())
664        && ((GLXDrawable )myWindow   == glXGetCurrentDrawable()));
665 #endif
666 }
667
668 // =======================================================================
669 // function : MakeCurrent
670 // purpose  :
671 // =======================================================================
672 Standard_Boolean OpenGl_Context::MakeCurrent()
673 {
674 #if defined(HAVE_EGL)
675   if ((EGLDisplay )myDisplay  == EGL_NO_DISPLAY
676    || (EGLContext )myGContext == EGL_NO_CONTEXT)
677   {
678     Standard_ProgramError_Raise_if (myIsInitialized, "OpenGl_Context::Init() should be called before!");
679     return Standard_False;
680   }
681
682   if (eglMakeCurrent ((EGLDisplay )myDisplay, (EGLSurface )myWindow, (EGLSurface )myWindow, (EGLContext )myGContext) != EGL_TRUE)
683   {
684     // if there is no current context it might be impossible to use glGetError() correctly
685     PushMessage (GL_DEBUG_SOURCE_WINDOW_SYSTEM, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
686                  "eglMakeCurrent() has failed!");
687     myIsInitialized = Standard_False;
688     return Standard_False;
689   }
690 #elif defined(_WIN32)
691   if (myWindowDC == NULL || myGContext == NULL)
692   {
693     Standard_ProgramError_Raise_if (myIsInitialized, "OpenGl_Context::Init() should be called before!");
694     return Standard_False;
695   }
696
697   // technically it should be safe to activate already bound GL context
698   // however some drivers (Intel etc.) may FAIL doing this for unknown reason
699   if (IsCurrent())
700   {
701     myShaderManager->SetContext (this);
702     return Standard_True;
703   }
704   else if (wglMakeCurrent ((HDC )myWindowDC, (HGLRC )myGContext) != TRUE)
705   {
706     // notice that glGetError() couldn't be used here!
707     wchar_t* aMsgBuff = NULL;
708     DWORD anErrorCode = GetLastError();
709     FormatMessageW (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
710                     NULL, anErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (wchar_t* )&aMsgBuff, 0, NULL);
711     TCollection_ExtendedString aMsg ("wglMakeCurrent() has failed. ");
712     if (aMsgBuff != NULL)
713     {
714       aMsg += (Standard_ExtString )aMsgBuff;
715       LocalFree (aMsgBuff);
716     }
717     PushMessage (GL_DEBUG_SOURCE_WINDOW_SYSTEM, GL_DEBUG_TYPE_ERROR, (unsigned int )anErrorCode, GL_DEBUG_SEVERITY_HIGH, aMsg);
718     myIsInitialized = Standard_False;
719     return Standard_False;
720   }
721 #else
722   if (myDisplay == NULL || myWindow == 0 || myGContext == 0)
723   {
724     Standard_ProgramError_Raise_if (myIsInitialized, "OpenGl_Context::Init() should be called before!");
725     return Standard_False;
726   }
727
728   if (!glXMakeCurrent ((Display* )myDisplay, (GLXDrawable )myWindow, (GLXContext )myGContext))
729   {
730     // if there is no current context it might be impossible to use glGetError() correctly
731     PushMessage (GL_DEBUG_SOURCE_WINDOW_SYSTEM, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
732                  "glXMakeCurrent() has failed!");
733     myIsInitialized = Standard_False;
734     return Standard_False;
735   }
736 #endif
737   myShaderManager->SetContext (this);
738   return Standard_True;
739 }
740
741 // =======================================================================
742 // function : SwapBuffers
743 // purpose  :
744 // =======================================================================
745 void OpenGl_Context::SwapBuffers()
746 {
747 #if defined(HAVE_EGL)
748   if ((EGLSurface )myWindow != EGL_NO_SURFACE)
749   {
750     eglSwapBuffers ((EGLDisplay )myDisplay, (EGLSurface )myWindow);
751   }
752 #elif defined(_WIN32)
753   if ((HDC )myWindowDC != NULL)
754   {
755     ::SwapBuffers ((HDC )myWindowDC);
756     glFlush();
757   }
758 #else
759   if ((Display* )myDisplay != NULL)
760   {
761     glXSwapBuffers ((Display* )myDisplay, (GLXDrawable )myWindow);
762   }
763 #endif
764 }
765
766 #endif // __APPLE__
767
768 // =======================================================================
769 // function : SetSwapInterval
770 // purpose  :
771 // =======================================================================
772 Standard_Boolean OpenGl_Context::SetSwapInterval (const Standard_Integer theInterval)
773 {
774 #if defined(HAVE_EGL)
775   if (::eglSwapInterval ((EGLDisplay )myDisplay, theInterval) == EGL_TRUE)
776   {
777     return Standard_True;
778   }
779 #elif defined(_WIN32)
780   if (myFuncs->wglSwapIntervalEXT != NULL)
781   {
782     myFuncs->wglSwapIntervalEXT (theInterval);
783     return Standard_True;
784   }
785 #elif defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
786   //
787 #elif defined(__APPLE__)
788   if (::CGLSetParameter (CGLGetCurrentContext(), kCGLCPSwapInterval, &theInterval) == kCGLNoError)
789   {
790     return Standard_True;
791   }
792 #else
793   if (theInterval == -1
794    && myFuncs->glXSwapIntervalEXT != NULL)
795   {
796     typedef int (*glXSwapIntervalEXT_t_x)(Display* theDisplay, GLXDrawable theDrawable, int theInterval);
797     glXSwapIntervalEXT_t_x aFuncPtr = (glXSwapIntervalEXT_t_x )myFuncs->glXSwapIntervalEXT;
798     aFuncPtr ((Display* )myDisplay, (GLXDrawable )myWindow, theInterval);
799     return Standard_True;
800   }
801   else if (myFuncs->glXSwapIntervalSGI != NULL)
802   {
803     myFuncs->glXSwapIntervalSGI (theInterval);
804     return Standard_True;
805   }
806 #endif
807   return Standard_False;
808 }
809
810 // =======================================================================
811 // function : findProc
812 // purpose  :
813 // =======================================================================
814 void* OpenGl_Context::findProc (const char* theFuncName)
815 {
816 #if defined(HAVE_EGL)
817   return (void* )eglGetProcAddress (theFuncName);
818 #elif defined(_WIN32)
819   return (void* )wglGetProcAddress (theFuncName);
820 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
821   return (myGlLibHandle != NULL) ? dlsym (myGlLibHandle, theFuncName) : NULL;
822 #else
823   return (void* )glXGetProcAddress ((const GLubyte* )theFuncName);
824 #endif
825 }
826
827 // =======================================================================
828 // function : CheckExtension
829 // purpose  :
830 // =======================================================================
831 Standard_Boolean OpenGl_Context::CheckExtension (const char* theExtName) const
832 {
833   if (theExtName  == NULL)
834   {
835 #ifdef OCCT_DEBUG
836     std::cerr << "CheckExtension called with NULL string!\n";
837 #endif
838     return Standard_False;
839   }
840   else if (caps->contextNoExtensions)
841   {
842     return Standard_False;
843   }
844
845 #if !defined(GL_ES_VERSION_2_0)
846   // available since OpenGL 3.0
847   // and the ONLY way to check extensions with OpenGL 3.1+ core profile
848   if (IsGlGreaterEqual (3, 0)
849    && myFuncs->glGetStringi != NULL)
850   {
851     GLint anExtNb = 0;
852     ::glGetIntegerv (GL_NUM_EXTENSIONS, &anExtNb);
853     const size_t anExtNameLen = strlen (theExtName);
854     for (GLint anIter = 0; anIter < anExtNb; ++anIter)
855     {
856       const char* anExtension = (const char* )myFuncs->glGetStringi (GL_EXTENSIONS, (GLuint )anIter);
857       const size_t aTestExtNameLen = strlen (anExtension);
858       if (aTestExtNameLen == anExtNameLen
859        && strncmp (anExtension, theExtName, anExtNameLen) == 0)
860       {
861         return Standard_True;
862       }
863     }
864     return Standard_False;
865   }
866 #endif
867
868   // use old way with huge string for all extensions
869   const char* anExtString = (const char* )glGetString (GL_EXTENSIONS);
870   if (anExtString == NULL)
871   {
872     Messenger()->Send ("TKOpenGL: glGetString (GL_EXTENSIONS) has returned NULL! No GL context?", Message_Warning);
873     return Standard_False;
874   }
875   return CheckExtension (anExtString, theExtName);
876 }
877
878 // =======================================================================
879 // function : CheckExtension
880 // purpose  :
881 // =======================================================================
882 Standard_Boolean OpenGl_Context::CheckExtension (const char* theExtString,
883                                                  const char* theExtName)
884 {
885   if (theExtString == NULL)
886   {
887     return Standard_False;
888   }
889
890   // Search for theExtName in the extensions string.
891   // Use of strstr() is not sufficient because extension names can be prefixes of other extension names.
892   char* aPtrIter = (char* )theExtString;
893   const char*  aPtrEnd      = aPtrIter + strlen (theExtString);
894   const size_t anExtNameLen = strlen (theExtName);
895   while (aPtrIter < aPtrEnd)
896   {
897     const size_t n = strcspn (aPtrIter, " ");
898     if ((n == anExtNameLen) && (strncmp (aPtrIter, theExtName, anExtNameLen) == 0))
899     {
900       return Standard_True;
901     }
902     aPtrIter += (n + 1);
903   }
904   return Standard_False;
905 }
906
907 #if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
908
909 // =======================================================================
910 // function : Init
911 // purpose  :
912 // =======================================================================
913 Standard_Boolean OpenGl_Context::Init (const Standard_Boolean theIsCoreProfile)
914 {
915   if (myIsInitialized)
916   {
917     return Standard_True;
918   }
919
920 #if defined(HAVE_EGL)
921   myDisplay  = (Aspect_Display )eglGetCurrentDisplay();
922   myGContext = (Aspect_RenderingContext )eglGetCurrentContext();
923   myWindow   = (Aspect_Drawable )eglGetCurrentSurface(EGL_DRAW);
924 #elif defined(_WIN32)
925   myWindowDC = (Aspect_Handle )wglGetCurrentDC();
926   myGContext = (Aspect_RenderingContext )wglGetCurrentContext();
927 #else
928   myDisplay  = (Aspect_Display )glXGetCurrentDisplay();
929   myGContext = (Aspect_RenderingContext )glXGetCurrentContext();
930   myWindow   = (Aspect_Drawable )glXGetCurrentDrawable();
931 #endif
932   if (myGContext == NULL)
933   {
934     return Standard_False;
935   }
936
937   init (theIsCoreProfile);
938   myIsInitialized = Standard_True;
939   return Standard_True;
940 }
941
942 #endif // __APPLE__
943
944 // =======================================================================
945 // function : Init
946 // purpose  :
947 // =======================================================================
948 #if defined(HAVE_EGL)
949 Standard_Boolean OpenGl_Context::Init (const Aspect_Drawable         theEglSurface,
950                                        const Aspect_Display          theEglDisplay,
951                                        const Aspect_RenderingContext theEglContext,
952                                        const Standard_Boolean        theIsCoreProfile)
953 #elif defined(_WIN32)
954 Standard_Boolean OpenGl_Context::Init (const Aspect_Handle           theWindow,
955                                        const Aspect_Handle           theWindowDC,
956                                        const Aspect_RenderingContext theGContext,
957                                        const Standard_Boolean        theIsCoreProfile)
958 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
959
960 #if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
961 Standard_Boolean OpenGl_Context::Init (EAGLContext*                  theGContext,
962                                        const Standard_Boolean        theIsCoreProfile)
963 #else
964 Standard_Boolean OpenGl_Context::Init (NSOpenGLContext*              theGContext,
965                                        const Standard_Boolean        theIsCoreProfile)
966 #endif
967
968 #else
969 Standard_Boolean OpenGl_Context::Init (const Aspect_Drawable         theWindow,
970                                        const Aspect_Display          theDisplay,
971                                        const Aspect_RenderingContext theGContext,
972                                        const Standard_Boolean        theIsCoreProfile)
973 #endif
974 {
975   Standard_ProgramError_Raise_if (myIsInitialized, "OpenGl_Context::Init() should be called only once!");
976 #if defined(HAVE_EGL)
977   myWindow   = theEglSurface;
978   myGContext = theEglContext;
979   myDisplay  = theEglDisplay;
980 #elif defined(_WIN32)
981   myWindow   = theWindow;
982   myGContext = theGContext;
983   myWindowDC = theWindowDC;
984 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
985   myGContext = theGContext;
986 #else
987   myWindow   = theWindow;
988   myGContext = theGContext;
989   myDisplay  = theDisplay;
990 #endif
991   if (myGContext == NULL || !MakeCurrent())
992   {
993     return Standard_False;
994   }
995
996   init (theIsCoreProfile);
997   myIsInitialized = Standard_True;
998   return Standard_True;
999 }
1000
1001 // =======================================================================
1002 // function : ResetErrors
1003 // purpose  :
1004 // =======================================================================
1005 bool OpenGl_Context::ResetErrors (const bool theToPrintErrors)
1006 {
1007   int aPrevErr = 0;
1008   int anErr    = ::glGetError();
1009   const bool hasError = anErr != GL_NO_ERROR;
1010   if (!theToPrintErrors)
1011   {
1012     for (; anErr != GL_NO_ERROR && aPrevErr != anErr; aPrevErr = anErr, anErr = ::glGetError())
1013     {
1014       //
1015     }
1016     return hasError;
1017   }
1018
1019   for (; anErr != GL_NO_ERROR && aPrevErr != anErr; aPrevErr = anErr, anErr = ::glGetError())
1020   {
1021     TCollection_ExtendedString anErrId;
1022     switch (anErr)
1023     {
1024       case GL_INVALID_ENUM:      anErrId = "GL_INVALID_ENUM";      break;
1025       case GL_INVALID_VALUE:     anErrId = "GL_INVALID_VALUE";     break;
1026       case GL_INVALID_OPERATION: anErrId = "GL_INVALID_OPERATION"; break;
1027     #ifdef GL_STACK_OVERFLOW
1028       case GL_STACK_OVERFLOW:    anErrId = "GL_STACK_OVERFLOW";    break;
1029       case GL_STACK_UNDERFLOW:   anErrId = "GL_STACK_UNDERFLOW";   break;
1030     #endif
1031       case GL_OUT_OF_MEMORY:     anErrId = "GL_OUT_OF_MEMORY";     break;
1032       case GL_INVALID_FRAMEBUFFER_OPERATION:
1033         anErrId = "GL_INVALID_FRAMEBUFFER_OPERATION";
1034         break;
1035       default:
1036         anErrId = TCollection_ExtendedString("#") + anErr;
1037         break;
1038     }
1039
1040     const TCollection_ExtendedString aMsg = TCollection_ExtendedString ("Unhandled GL error: ") + anErrId;
1041     PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_OTHER, 0, GL_DEBUG_SEVERITY_LOW, aMsg);
1042   }
1043   return hasError;
1044 }
1045
1046 // =======================================================================
1047 // function : ReadGlVersion
1048 // purpose  :
1049 // =======================================================================
1050 void OpenGl_Context::ReadGlVersion (Standard_Integer& theGlVerMajor,
1051                                     Standard_Integer& theGlVerMinor)
1052 {
1053   // reset values
1054   theGlVerMajor = 0;
1055   theGlVerMinor = 0;
1056
1057   bool toCheckVer3 = true;
1058 #if defined(__EMSCRIPTEN__)
1059   // WebGL 1.0 prints annoying invalid enumeration warnings to console.
1060   toCheckVer3 = false;
1061   if (EMSCRIPTEN_WEBGL_CONTEXT_HANDLE aWebGlCtx = emscripten_webgl_get_current_context())
1062   {
1063     EmscriptenWebGLContextAttributes anAttribs = {};
1064     if (emscripten_webgl_get_context_attributes (aWebGlCtx, &anAttribs) == EMSCRIPTEN_RESULT_SUCCESS)
1065     {
1066       toCheckVer3 = anAttribs.majorVersion >= 2;
1067     }
1068   }
1069 #endif
1070
1071   // Available since OpenGL 3.0 and OpenGL ES 3.0.
1072   if (toCheckVer3)
1073   {
1074     GLint aMajor = 0, aMinor = 0;
1075     glGetIntegerv (GL_MAJOR_VERSION, &aMajor);
1076     glGetIntegerv (GL_MINOR_VERSION, &aMinor);
1077     // glGetError() sometimes does not report an error here even if
1078     // GL does not know GL_MAJOR_VERSION and GL_MINOR_VERSION constants.
1079     // This happens on some renderers like e.g. Cygwin MESA.
1080     // Thus checking additionally if GL has put anything to
1081     // the output variables.
1082     if (::glGetError() == GL_NO_ERROR && aMajor != 0 && aMinor != 0)
1083     {
1084       theGlVerMajor = aMajor;
1085       theGlVerMinor = aMinor;
1086       return;
1087     }
1088     for (GLenum anErr = ::glGetError(), aPrevErr = GL_NO_ERROR;; aPrevErr = anErr, anErr = ::glGetError())
1089     {
1090       if (anErr == GL_NO_ERROR
1091        || anErr == aPrevErr)
1092       {
1093         break;
1094       }
1095     }
1096   }
1097
1098   // Read version string.
1099   // Notice that only first two numbers split by point '2.1 XXXXX' are significant.
1100   // Following trash (after space) is vendor-specific.
1101   // New drivers also returns micro version of GL like '3.3.0' which has no meaning
1102   // and should be considered as vendor-specific too.
1103   const char* aVerStr = (const char* )glGetString (GL_VERSION);
1104   if (aVerStr == NULL || *aVerStr == '\0')
1105   {
1106     // invalid GL context
1107     return;
1108   }
1109
1110 //#if defined(GL_ES_VERSION_2_0)
1111   // skip "OpenGL ES-** " section
1112   for (; *aVerStr != '\0'; ++aVerStr)
1113   {
1114     if (*aVerStr >= '0' && *aVerStr <= '9')
1115     {
1116       break;
1117     }
1118   }
1119 //#endif
1120
1121   // parse string for major number
1122   char aMajorStr[32];
1123   char aMinorStr[32];
1124   size_t aMajIter = 0;
1125   while (aVerStr[aMajIter] >= '0' && aVerStr[aMajIter] <= '9')
1126   {
1127     ++aMajIter;
1128   }
1129   if (aMajIter == 0 || aMajIter >= sizeof(aMajorStr))
1130   {
1131     return;
1132   }
1133   memcpy (aMajorStr, aVerStr, aMajIter);
1134   aMajorStr[aMajIter] = '\0';
1135
1136   // parse string for minor number
1137   aVerStr += aMajIter + 1;
1138   size_t aMinIter = 0;
1139   while (aVerStr[aMinIter] >= '0' && aVerStr[aMinIter] <= '9')
1140   {
1141     ++aMinIter;
1142   }
1143   if (aMinIter == 0 || aMinIter >= sizeof(aMinorStr))
1144   {
1145     return;
1146   }
1147   memcpy (aMinorStr, aVerStr, aMinIter);
1148   aMinorStr[aMinIter] = '\0';
1149
1150   // read numbers
1151   theGlVerMajor = atoi (aMajorStr);
1152   theGlVerMinor = atoi (aMinorStr);
1153
1154   if (theGlVerMajor <= 0)
1155   {
1156     theGlVerMajor = 0;
1157     theGlVerMinor = 0;
1158   }
1159 }
1160
1161 static Standard_CString THE_DBGMSG_UNKNOWN = "UNKNOWN";
1162 static Standard_CString THE_DBGMSG_SOURCES[] =
1163 {
1164   ".OpenGL",    // GL_DEBUG_SOURCE_API
1165   ".WinSystem", // GL_DEBUG_SOURCE_WINDOW_SYSTEM
1166   ".GLSL",      // GL_DEBUG_SOURCE_SHADER_COMPILER
1167   ".3rdParty",  // GL_DEBUG_SOURCE_THIRD_PARTY
1168   "",           // GL_DEBUG_SOURCE_APPLICATION
1169   ".Other"      // GL_DEBUG_SOURCE_OTHER
1170 };
1171
1172 static Standard_CString THE_DBGMSG_TYPES[] =
1173 {
1174   "Error",           // GL_DEBUG_TYPE_ERROR
1175   "Deprecated",      // GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR
1176   "Undef. behavior", // GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR
1177   "Portability",     // GL_DEBUG_TYPE_PORTABILITY
1178   "Performance",     // GL_DEBUG_TYPE_PERFORMANCE
1179   "Other"            // GL_DEBUG_TYPE_OTHER
1180 };
1181
1182 static Standard_CString THE_DBGMSG_SEV_HIGH   = "High";   // GL_DEBUG_SEVERITY_HIGH
1183 static Standard_CString THE_DBGMSG_SEV_MEDIUM = "Medium"; // GL_DEBUG_SEVERITY_MEDIUM
1184 static Standard_CString THE_DBGMSG_SEV_LOW    = "Low";    // GL_DEBUG_SEVERITY_LOW
1185
1186 //! Callback for GL_ARB_debug_output extension
1187 static void APIENTRY debugCallbackWrap(unsigned int theSource,
1188                                        unsigned int theType,
1189                                        unsigned int theId,
1190                                        unsigned int theSeverity,
1191                                        int          /*theLength*/,
1192                                        const char*  theMessage,
1193                                        const void*  theUserParam)
1194 {
1195   OpenGl_Context* aCtx = (OpenGl_Context* )theUserParam;
1196   aCtx->PushMessage (theSource, theType, theId, theSeverity, theMessage);
1197 }
1198
1199 // =======================================================================
1200 // function : PushMessage
1201 // purpose  :
1202 // =======================================================================
1203 void OpenGl_Context::PushMessage (const unsigned int theSource,
1204                                   const unsigned int theType,
1205                                   const unsigned int theId,
1206                                   const unsigned int theSeverity,
1207                                   const TCollection_ExtendedString& theMessage)
1208 {
1209   if (caps->suppressExtraMsg
1210    && theSource >= GL_DEBUG_SOURCE_API
1211    && theSource <= GL_DEBUG_SOURCE_OTHER
1212    && myFilters[theSource - GL_DEBUG_SOURCE_API].Contains (theId))
1213   {
1214     return;
1215   }
1216
1217   Standard_CString& aSrc = (theSource >= GL_DEBUG_SOURCE_API
1218                         && theSource <= GL_DEBUG_SOURCE_OTHER)
1219                          ? THE_DBGMSG_SOURCES[theSource - GL_DEBUG_SOURCE_API]
1220                          : THE_DBGMSG_UNKNOWN;
1221   Standard_CString& aType = (theType >= GL_DEBUG_TYPE_ERROR
1222                          && theType <= GL_DEBUG_TYPE_OTHER)
1223                           ? THE_DBGMSG_TYPES[theType - GL_DEBUG_TYPE_ERROR]
1224                           : THE_DBGMSG_UNKNOWN;
1225   Standard_CString& aSev = theSeverity == GL_DEBUG_SEVERITY_HIGH
1226                          ? THE_DBGMSG_SEV_HIGH
1227                          : (theSeverity == GL_DEBUG_SEVERITY_MEDIUM
1228                           ? THE_DBGMSG_SEV_MEDIUM
1229                           : THE_DBGMSG_SEV_LOW);
1230   Message_Gravity aGrav = theSeverity == GL_DEBUG_SEVERITY_HIGH
1231                         ? Message_Alarm
1232                         : (theSeverity == GL_DEBUG_SEVERITY_MEDIUM
1233                          ? Message_Warning
1234                          : Message_Info);
1235
1236   TCollection_ExtendedString aMsg;
1237   aMsg += "TKOpenGl"; aMsg += aSrc;
1238   aMsg += " | Type: ";        aMsg += aType;
1239   aMsg += " | ID: ";          aMsg += (Standard_Integer )theId;
1240   aMsg += " | Severity: ";    aMsg += aSev;
1241   aMsg += " | Message:\n  ";
1242   aMsg += theMessage;
1243   Messenger()->Send (aMsg, aGrav);
1244 }
1245
1246 // =======================================================================
1247 // function : ExcludeMessage
1248 // purpose  :
1249 // ======================================================================
1250 Standard_Boolean OpenGl_Context::ExcludeMessage (const unsigned int theSource,
1251                                                  const unsigned int theId)
1252 {
1253   return theSource >= GL_DEBUG_SOURCE_API
1254       && theSource <= GL_DEBUG_SOURCE_OTHER
1255       && myFilters[theSource - GL_DEBUG_SOURCE_API].Add (theId);
1256 }
1257
1258 // =======================================================================
1259 // function : IncludeMessage
1260 // purpose  :
1261 // ======================================================================
1262 Standard_Boolean OpenGl_Context::IncludeMessage (const unsigned int theSource,
1263                                                  const unsigned int theId)
1264 {
1265   return theSource >= GL_DEBUG_SOURCE_API
1266       && theSource <= GL_DEBUG_SOURCE_OTHER
1267       && myFilters[theSource - GL_DEBUG_SOURCE_API].Remove (theId);
1268 }
1269
1270 // =======================================================================
1271 // function : checkWrongVersion
1272 // purpose  :
1273 // ======================================================================
1274 void OpenGl_Context::checkWrongVersion (Standard_Integer theGlVerMajor, Standard_Integer theGlVerMinor,
1275                                         const char* theLastFailedProc)
1276 {
1277   if (!IsGlGreaterEqual (theGlVerMajor, theGlVerMinor))
1278   {
1279     return;
1280   }
1281
1282   PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
1283                TCollection_AsciiString()
1284                + "Error! OpenGL context reports version "
1285                + myGlVerMajor  + "." + myGlVerMinor
1286                + " but does not export required functions for " + theGlVerMajor + "." + theGlVerMinor
1287                + " (" + (theLastFailedProc != NULL ? theLastFailedProc : "") + ")\n"
1288                + "Please report this issue to OpenGL driver vendor '" + myVendor + "'");
1289
1290   // lower internal version
1291   if (theGlVerMinor > 0)
1292   {
1293     myGlVerMajor = theGlVerMajor;
1294     myGlVerMinor = theGlVerMinor - 1;
1295     return;
1296   }
1297 #if defined(GL_ES_VERSION_2_0)
1298   switch (theGlVerMajor)
1299   {
1300     case 3: myGlVerMajor = 2; myGlVerMinor = 0; return;
1301   }
1302 #else
1303   switch (theGlVerMajor)
1304   {
1305     case 2: myGlVerMajor = 1; myGlVerMinor = 5; return;
1306     case 3: myGlVerMajor = 2; myGlVerMinor = 1; return;
1307     case 4: myGlVerMajor = 3; myGlVerMinor = 3; return;
1308   }
1309 #endif
1310 }
1311
1312 // =======================================================================
1313 // function : init
1314 // purpose  :
1315 // =======================================================================
1316 void OpenGl_Context::init (const Standard_Boolean theIsCoreProfile)
1317 {
1318   // read version
1319   myGlVerMajor = 0;
1320   myGlVerMinor = 0;
1321   myMaxMsaaSamples = 0;
1322   myMaxDrawBuffers = 1;
1323   myMaxColorAttachments = 1;
1324   ReadGlVersion (myGlVerMajor, myGlVerMinor);
1325   myVendor = (const char* )::glGetString (GL_VENDOR);
1326   myVendor.LowerCase();
1327
1328   // standard formats
1329   mySupportedFormats->Clear();
1330   mySupportedFormats->Add (Image_PixMap::ImgGray);
1331   mySupportedFormats->Add (Image_PixMap::ImgAlpha);
1332   mySupportedFormats->Add (Image_PixMap::ImgRGB);
1333   mySupportedFormats->Add (Image_PixMap::ImgRGB32);
1334   mySupportedFormats->Add (Image_PixMap::ImgRGBA);
1335
1336   if (caps->contextMajorVersionUpper != -1)
1337   {
1338     // synthetically restrict OpenGL version for testing
1339     Standard_Integer aCtxVer[2] = { myGlVerMajor, myGlVerMinor };
1340     bool isLowered = false;
1341     if (myGlVerMajor > caps->contextMajorVersionUpper)
1342     {
1343       isLowered = true;
1344       myGlVerMajor = caps->contextMajorVersionUpper;
1345     #if defined(GL_ES_VERSION_2_0)
1346       switch (myGlVerMajor)
1347       {
1348         case 2: myGlVerMinor = 0; break;
1349       }
1350     #else
1351       switch (myGlVerMajor)
1352       {
1353         case 1: myGlVerMinor = 5; break;
1354         case 2: myGlVerMinor = 1; break;
1355         case 3: myGlVerMinor = 3; break;
1356       }
1357     #endif
1358     }
1359     if (caps->contextMinorVersionUpper != -1
1360      && myGlVerMinor > caps->contextMinorVersionUpper)
1361     {
1362       isLowered = true;
1363       myGlVerMinor = caps->contextMinorVersionUpper;
1364     }
1365     if (isLowered)
1366     {
1367       PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
1368                    TCollection_AsciiString ("OpenGL version ") + aCtxVer[0] + "." + aCtxVer[1]
1369                    + " has been lowered to " + myGlVerMajor + "." + myGlVerMinor);
1370     }
1371   }
1372
1373   if (!caps->ffpEnable
1374    && !IsGlGreaterEqual (2, 0))
1375   {
1376     caps->ffpEnable = true;
1377     TCollection_ExtendedString aMsg =
1378       TCollection_ExtendedString("OpenGL driver is too old! Context info:\n")
1379                                + "    Vendor:   " + (const char* )::glGetString (GL_VENDOR)   + "\n"
1380                                + "    Renderer: " + (const char* )::glGetString (GL_RENDERER) + "\n"
1381                                + "    Version:  " + (const char* )::glGetString (GL_VERSION)  + "\n"
1382                                + "  Fallback using deprecated fixed-function pipeline.\n"
1383                                + "  Visualization might work incorrectly.\n"
1384                                  "  Consider upgrading the graphics driver.";
1385     PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH, aMsg);
1386   }
1387
1388 #if defined(GL_ES_VERSION_2_0)
1389   (void )theIsCoreProfile;
1390   const bool isCoreProfile = false;
1391 #else
1392
1393   if (myVendor.Search ("nvidia") != -1)
1394   {
1395     // Buffer detailed info: Buffer object 1 (bound to GL_ARRAY_BUFFER_ARB, usage hint is GL_STATIC_DRAW)
1396     // will use VIDEO memory as the source for buffer object operations.
1397     ExcludeMessage (GL_DEBUG_SOURCE_API, 131185);
1398   }
1399   if (IsGlGreaterEqual (3, 0))
1400   {
1401     // retrieve auxiliary function in advance
1402     FindProc ("glGetStringi", myFuncs->glGetStringi);
1403   }
1404
1405   bool isCoreProfile = false;
1406   if (IsGlGreaterEqual (3, 2))
1407   {
1408     isCoreProfile = (theIsCoreProfile == Standard_True);
1409
1410     // detect Core profile
1411     if (!isCoreProfile)
1412     {
1413       GLint aProfile = 0;
1414       ::glGetIntegerv (GL_CONTEXT_PROFILE_MASK, &aProfile);
1415       isCoreProfile = (aProfile & GL_CONTEXT_CORE_PROFILE_BIT) != 0;
1416     }
1417   }
1418 #endif
1419
1420   core11     = NULL;
1421   if (!isCoreProfile)
1422   {
1423     core11 = (OpenGl_GlCore11* )(&(*myFuncs));
1424   }
1425   core11fwd  = (OpenGl_GlCore11Fwd* )(&(*myFuncs));
1426   core15     = NULL;
1427   core15fwd  = NULL;
1428   core20     = NULL;
1429   core20fwd  = NULL;
1430   core30     = NULL;
1431   core30fwd  = NULL;
1432   core32     = NULL;
1433   core32back = NULL;
1434   core33     = NULL;
1435   core33back = NULL;
1436   core41     = NULL;
1437   core41back = NULL;
1438   core42     = NULL;
1439   core42back = NULL;
1440   core43     = NULL;
1441   core43back = NULL;
1442   core44     = NULL;
1443   core44back = NULL;
1444   core45     = NULL;
1445   core45back = NULL;
1446   arbTBO     = NULL;
1447   arbTboRGB32 = Standard_False;
1448   arbIns     = NULL;
1449   arbDbg     = NULL;
1450   arbFBO     = NULL;
1451   arbFBOBlit = NULL;
1452   extGS      = NULL;
1453   myDefaultVao = 0;
1454
1455   //! Make record shorter to retrieve function pointer using variable with same name
1456   const char* aLastFailedProc = NULL;
1457   #define FindProcShort(theFunc) FindProcVerbose(aLastFailedProc, #theFunc, myFuncs->theFunc)
1458
1459 #if defined(GL_ES_VERSION_2_0)
1460
1461   hasTexRGBA8 = IsGlGreaterEqual (3, 0)
1462              || CheckExtension ("GL_OES_rgb8_rgba8");
1463   hasTexSRGB  = IsGlGreaterEqual (3, 0);
1464   hasFboSRGB  = IsGlGreaterEqual (3, 0);
1465   hasSRGBControl = CheckExtension ("GL_EXT_sRGB_write_control");
1466   // NPOT textures has limited support within OpenGL ES 2.0
1467   // which are relaxed by OpenGL ES 3.0 or some extensions
1468   //arbNPTW     = IsGlGreaterEqual (3, 0)
1469   //           || CheckExtension ("GL_OES_texture_npot")
1470   //           || CheckExtension ("GL_NV_texture_npot_2D_mipmap");
1471   arbNPTW     = Standard_True;
1472   arbTexRG    = IsGlGreaterEqual (3, 0)
1473              || CheckExtension ("GL_EXT_texture_rg");
1474   extBgra     = CheckExtension ("GL_EXT_texture_format_BGRA8888");
1475   extAnis = CheckExtension ("GL_EXT_texture_filter_anisotropic");
1476   extPDS  = IsGlGreaterEqual (3, 0)
1477          || CheckExtension ("GL_OES_packed_depth_stencil");
1478 #ifdef __EMSCRIPTEN__
1479   if (!extPDS
1480     && checkEnableWebGlExtension (*this, "GL_WEBGL_depth_texture"))
1481   {
1482     extPDS = true; // WebGL 1.0 extension (in WebGL 2.0 core)
1483   }
1484 #endif
1485
1486   if (extBgra)
1487   {
1488     // no BGR on OpenGL ES - only BGRA as extension
1489     mySupportedFormats->Add (Image_PixMap::ImgBGR32);
1490     mySupportedFormats->Add (Image_PixMap::ImgBGRA);
1491   }
1492
1493   core11fwd = (OpenGl_GlCore11Fwd* )(&(*myFuncs));
1494   if (IsGlGreaterEqual (2, 0))
1495   {
1496     // enable compatible functions
1497     core20    = (OpenGl_GlCore20*    )(&(*myFuncs));
1498     core20fwd = (OpenGl_GlCore20Fwd* )(&(*myFuncs));
1499     core15fwd = (OpenGl_GlCore15Fwd* )(&(*myFuncs));
1500     arbFBO    = (OpenGl_ArbFBO*      )(&(*myFuncs));
1501   }
1502   if (IsGlGreaterEqual (3, 0)
1503    && FindProcShort (glBlitFramebuffer))
1504   {
1505     arbFBOBlit = (OpenGl_ArbFBOBlit* )(&(*myFuncs));
1506   }
1507   if (IsGlGreaterEqual (3, 0)
1508    && FindProcShort (glGenSamplers)
1509    && FindProcShort (glDeleteSamplers)
1510    && FindProcShort (glIsSampler)
1511    && FindProcShort (glBindSampler)
1512    && FindProcShort (glSamplerParameteri)
1513    && FindProcShort (glSamplerParameteriv)
1514    && FindProcShort (glSamplerParameterf)
1515    && FindProcShort (glSamplerParameterfv)
1516    && FindProcShort (glGetSamplerParameteriv)
1517    && FindProcShort (glGetSamplerParameterfv))
1518    //&& FindProcShort (glSamplerParameterIiv) // only on Desktop or with extensions GL_OES_texture_border_clamp/GL_EXT_texture_border_clamp
1519    //&& FindProcShort (glSamplerParameterIuiv)
1520    //&& FindProcShort (glGetSamplerParameterIiv)
1521    //&& FindProcShort (glGetSamplerParameterIuiv))
1522   {
1523     arbSamplerObject = (OpenGl_ArbSamplerObject* )(&(*myFuncs));
1524   }
1525   extFragDepth = !IsGlGreaterEqual(3, 0)
1526                && CheckExtension ("GL_EXT_frag_depth");
1527   if (IsGlGreaterEqual (3, 1)
1528    && FindProcShort (glTexStorage2DMultisample))
1529   {
1530     // MSAA RenderBuffers have been defined in OpenGL ES 3.0,
1531     // but MSAA Textures - only in OpenGL ES 3.1+
1532     ::glGetIntegerv (GL_MAX_SAMPLES, &myMaxMsaaSamples);
1533   }
1534
1535   hasUintIndex = IsGlGreaterEqual (3, 0)
1536               || CheckExtension ("GL_OES_element_index_uint");
1537   hasHighp     = CheckExtension ("GL_OES_fragment_precision_high");
1538   GLint aRange[2] = {0, 0};
1539   GLint aPrec     = 0;
1540   ::glGetShaderPrecisionFormat (GL_FRAGMENT_SHADER, GL_HIGH_FLOAT, aRange, &aPrec);
1541   if (aPrec != 0)
1542   {
1543     hasHighp = Standard_True;
1544   }
1545
1546   arbTexFloat = (IsGlGreaterEqual (3, 0)
1547               && FindProcShort (glTexImage3D))
1548               || CheckExtension ("GL_OES_texture_float");
1549   hasTexFloatLinear = arbTexFloat
1550                    && CheckExtension ("GL_OES_texture_float_linear");
1551
1552   const bool hasTexBuffer32  = IsGlGreaterEqual (3, 2) && FindProcShort (glTexBuffer);
1553   const bool hasExtTexBuffer = CheckExtension ("GL_EXT_texture_buffer") && FindProc ("glTexBufferEXT", myFuncs->glTexBuffer);
1554   if (hasTexBuffer32 || hasExtTexBuffer)
1555   {
1556     arbTBO = reinterpret_cast<OpenGl_ArbTBO*> (myFuncs.get());
1557   }
1558
1559   bool hasInstanced = IsGlGreaterEqual (3, 0)
1560        && FindProcShort (glVertexAttribDivisor)
1561        && FindProcShort (glDrawArraysInstanced)
1562        && FindProcShort (glDrawElementsInstanced);
1563   if (!hasInstanced)
1564   {
1565     hasInstanced = CheckExtension ("GL_ANGLE_instanced_arrays")
1566        && FindProc ("glVertexAttribDivisorANGLE",   myFuncs->glVertexAttribDivisor)
1567        && FindProc ("glDrawArraysInstancedANGLE",   myFuncs->glDrawArraysInstanced)
1568        && FindProc ("glDrawElementsInstancedANGLE", myFuncs->glDrawElementsInstanced);
1569   }
1570   if (hasInstanced)
1571   {
1572     arbIns = (OpenGl_ArbIns* )(&(*myFuncs));
1573   }
1574
1575   const bool hasVAO = IsGlGreaterEqual (3, 0)
1576        && FindProcShort (glBindVertexArray)
1577        && FindProcShort (glDeleteVertexArrays)
1578        && FindProcShort (glGenVertexArrays)
1579        && FindProcShort (glIsVertexArray);
1580 #ifndef __EMSCRIPTEN__ // latest Emscripten does not pretend having / simulating mapping buffer functions
1581   const bool hasMapBufferRange = IsGlGreaterEqual (3, 0)
1582        && FindProcShort (glMapBufferRange)
1583        && FindProcShort (glUnmapBuffer)
1584        && FindProcShort (glGetBufferPointerv)
1585        && FindProcShort (glFlushMappedBufferRange);
1586 #endif
1587
1588   // load OpenGL ES 3.0 new functions
1589   const bool has30es = IsGlGreaterEqual (3, 0)
1590        && hasVAO
1591     #ifndef __EMSCRIPTEN__
1592        && hasMapBufferRange
1593     #endif
1594        && hasInstanced
1595        && arbSamplerObject != NULL
1596        && arbFBOBlit != NULL
1597        && FindProcShort (glReadBuffer)
1598        && FindProcShort (glDrawRangeElements)
1599        && FindProcShort (glTexImage3D)
1600        && FindProcShort (glTexSubImage3D)
1601        && FindProcShort (glCopyTexSubImage3D)
1602        && FindProcShort (glCompressedTexImage3D)
1603        && FindProcShort (glCompressedTexSubImage3D)
1604        && FindProcShort (glGenQueries)
1605        && FindProcShort (glDeleteQueries)
1606        && FindProcShort (glIsQuery)
1607        && FindProcShort (glBeginQuery)
1608        && FindProcShort (glEndQuery)
1609        && FindProcShort (glGetQueryiv)
1610        && FindProcShort (glGetQueryObjectuiv)
1611        && FindProcShort (glDrawBuffers)
1612        && FindProcShort (glUniformMatrix2x3fv)
1613        && FindProcShort (glUniformMatrix3x2fv)
1614        && FindProcShort (glUniformMatrix2x4fv)
1615        && FindProcShort (glUniformMatrix4x2fv)
1616        && FindProcShort (glUniformMatrix3x4fv)
1617        && FindProcShort (glUniformMatrix4x3fv)
1618        && FindProcShort (glRenderbufferStorageMultisample)
1619        && FindProcShort (glFramebufferTextureLayer)
1620        && FindProcShort (glGetIntegeri_v)
1621        && FindProcShort (glBeginTransformFeedback)
1622        && FindProcShort (glEndTransformFeedback)
1623        && FindProcShort (glBindBufferRange)
1624        && FindProcShort (glBindBufferBase)
1625        && FindProcShort (glTransformFeedbackVaryings)
1626        && FindProcShort (glGetTransformFeedbackVarying)
1627        && FindProcShort (glVertexAttribIPointer)
1628        && FindProcShort (glGetVertexAttribIiv)
1629        && FindProcShort (glGetVertexAttribIuiv)
1630        && FindProcShort (glVertexAttribI4i)
1631        && FindProcShort (glVertexAttribI4ui)
1632        && FindProcShort (glVertexAttribI4iv)
1633        && FindProcShort (glVertexAttribI4uiv)
1634        && FindProcShort (glGetUniformuiv)
1635        && FindProcShort (glGetFragDataLocation)
1636        && FindProcShort (glUniform1ui)
1637        && FindProcShort (glUniform2ui)
1638        && FindProcShort (glUniform3ui)
1639        && FindProcShort (glUniform4ui)
1640        && FindProcShort (glUniform1uiv)
1641        && FindProcShort (glUniform2uiv)
1642        && FindProcShort (glUniform3uiv)
1643        && FindProcShort (glUniform4uiv)
1644        && FindProcShort (glClearBufferiv)
1645        && FindProcShort (glClearBufferuiv)
1646        && FindProcShort (glClearBufferfv)
1647        && FindProcShort (glClearBufferfi)
1648        && FindProcShort (glGetStringi)
1649        && FindProcShort (glCopyBufferSubData)
1650        && FindProcShort (glGetUniformIndices)
1651        && FindProcShort (glGetActiveUniformsiv)
1652        && FindProcShort (glGetUniformBlockIndex)
1653        && FindProcShort (glGetActiveUniformBlockiv)
1654        && FindProcShort (glGetActiveUniformBlockName)
1655        && FindProcShort (glUniformBlockBinding)
1656        && FindProcShort (glFenceSync)
1657        && FindProcShort (glIsSync)
1658        && FindProcShort (glDeleteSync)
1659        && FindProcShort (glClientWaitSync)
1660        && FindProcShort (glWaitSync)
1661        && FindProcShort (glGetInteger64v)
1662        && FindProcShort (glGetSynciv)
1663        && FindProcShort (glGetInteger64i_v)
1664        && FindProcShort (glGetBufferParameteri64v)
1665        && FindProcShort (glBindTransformFeedback)
1666        && FindProcShort (glDeleteTransformFeedbacks)
1667        && FindProcShort (glGenTransformFeedbacks)
1668        && FindProcShort (glIsTransformFeedback)
1669        && FindProcShort (glPauseTransformFeedback)
1670        && FindProcShort (glResumeTransformFeedback)
1671        && FindProcShort (glGetProgramBinary)
1672        && FindProcShort (glProgramBinary)
1673        && FindProcShort (glProgramParameteri)
1674        && FindProcShort (glInvalidateFramebuffer)
1675        && FindProcShort (glInvalidateSubFramebuffer)
1676        && FindProcShort (glTexStorage2D)
1677        && FindProcShort (glTexStorage3D)
1678        && FindProcShort (glGetInternalformativ);
1679   if (!has30es)
1680   {
1681     checkWrongVersion (3, 0, aLastFailedProc);
1682   }
1683   else
1684   {
1685     core30    = (OpenGl_GlCore30*    )(&(*myFuncs));
1686     core30fwd = (OpenGl_GlCore30Fwd* )(&(*myFuncs));
1687     hasGetBufferData = true;
1688   }
1689
1690   // load OpenGL ES 3.1 new functions
1691   const bool has31es = IsGlGreaterEqual (3, 1)
1692        && has30es
1693        && FindProcShort (glDispatchCompute)
1694        && FindProcShort (glDispatchComputeIndirect)
1695        && FindProcShort (glDrawArraysIndirect)
1696        && FindProcShort (glDrawElementsIndirect)
1697        && FindProcShort (glFramebufferParameteri)
1698        && FindProcShort (glGetFramebufferParameteriv)
1699        && FindProcShort (glGetProgramInterfaceiv)
1700        && FindProcShort (glGetProgramResourceIndex)
1701        && FindProcShort (glGetProgramResourceName)
1702        && FindProcShort (glGetProgramResourceiv)
1703        && FindProcShort (glGetProgramResourceLocation)
1704        && FindProcShort (glUseProgramStages)
1705        && FindProcShort (glActiveShaderProgram)
1706        && FindProcShort (glCreateShaderProgramv)
1707        && FindProcShort (glBindProgramPipeline)
1708        && FindProcShort (glDeleteProgramPipelines)
1709        && FindProcShort (glGenProgramPipelines)
1710        && FindProcShort (glIsProgramPipeline)
1711        && FindProcShort (glGetProgramPipelineiv)
1712        && FindProcShort (glProgramUniform1i)
1713        && FindProcShort (glProgramUniform2i)
1714        && FindProcShort (glProgramUniform3i)
1715        && FindProcShort (glProgramUniform4i)
1716        && FindProcShort (glProgramUniform1ui)
1717        && FindProcShort (glProgramUniform2ui)
1718        && FindProcShort (glProgramUniform3ui)
1719        && FindProcShort (glProgramUniform4ui)
1720        && FindProcShort (glProgramUniform1f)
1721        && FindProcShort (glProgramUniform2f)
1722        && FindProcShort (glProgramUniform3f)
1723        && FindProcShort (glProgramUniform4f)
1724        && FindProcShort (glProgramUniform1iv)
1725        && FindProcShort (glProgramUniform2iv)
1726        && FindProcShort (glProgramUniform3iv)
1727        && FindProcShort (glProgramUniform4iv)
1728        && FindProcShort (glProgramUniform1uiv)
1729        && FindProcShort (glProgramUniform2uiv)
1730        && FindProcShort (glProgramUniform3uiv)
1731        && FindProcShort (glProgramUniform4uiv)
1732        && FindProcShort (glProgramUniform1fv)
1733        && FindProcShort (glProgramUniform2fv)
1734        && FindProcShort (glProgramUniform3fv)
1735        && FindProcShort (glProgramUniform4fv)
1736        && FindProcShort (glProgramUniformMatrix2fv)
1737        && FindProcShort (glProgramUniformMatrix3fv)
1738        && FindProcShort (glProgramUniformMatrix4fv)
1739        && FindProcShort (glProgramUniformMatrix2x3fv)
1740        && FindProcShort (glProgramUniformMatrix3x2fv)
1741        && FindProcShort (glProgramUniformMatrix2x4fv)
1742        && FindProcShort (glProgramUniformMatrix4x2fv)
1743        && FindProcShort (glProgramUniformMatrix3x4fv)
1744        && FindProcShort (glProgramUniformMatrix4x3fv)
1745        && FindProcShort (glValidateProgramPipeline)
1746        && FindProcShort (glGetProgramPipelineInfoLog)
1747        && FindProcShort (glBindImageTexture)
1748        && FindProcShort (glGetBooleani_v)
1749        && FindProcShort (glMemoryBarrier)
1750        && FindProcShort (glMemoryBarrierByRegion)
1751        && FindProcShort (glTexStorage2DMultisample)
1752        && FindProcShort (glGetMultisamplefv)
1753        && FindProcShort (glSampleMaski)
1754        && FindProcShort (glGetTexLevelParameteriv)
1755        && FindProcShort (glGetTexLevelParameterfv)
1756        && FindProcShort (glBindVertexBuffer)
1757        && FindProcShort (glVertexAttribFormat)
1758        && FindProcShort (glVertexAttribIFormat)
1759        && FindProcShort (glVertexAttribBinding)
1760        && FindProcShort (glVertexBindingDivisor);
1761   if (!has31es)
1762   {
1763     checkWrongVersion (3, 1, aLastFailedProc);
1764   }
1765
1766   // initialize debug context extension
1767   if (IsGlGreaterEqual (3, 2)
1768    || CheckExtension ("GL_KHR_debug"))
1769   {
1770     // this functionality become a part of OpenGL ES 3.2
1771     arbDbg = NULL;
1772     if (IsGlGreaterEqual (3, 2)
1773      && FindProcShort (glDebugMessageControl)
1774      && FindProcShort (glDebugMessageInsert)
1775      && FindProcShort (glDebugMessageCallback)
1776      && FindProcShort (glGetDebugMessageLog))
1777     {
1778       arbDbg = (OpenGl_ArbDbg* )(&(*myFuncs));
1779     }
1780     // According to GL_KHR_debug spec, all functions should have KHR suffix.
1781     // However, some implementations can export these functions without suffix.
1782     else if (!IsGlGreaterEqual (3, 2)
1783      && FindProc ("glDebugMessageControlKHR",  myFuncs->glDebugMessageControl)
1784      && FindProc ("glDebugMessageInsertKHR",   myFuncs->glDebugMessageInsert)
1785      && FindProc ("glDebugMessageCallbackKHR", myFuncs->glDebugMessageCallback)
1786      && FindProc ("glGetDebugMessageLogKHR",   myFuncs->glGetDebugMessageLog))
1787     {
1788       arbDbg = (OpenGl_ArbDbg* )(&(*myFuncs));
1789     }
1790
1791     if (arbDbg != NULL
1792      && caps->contextDebug)
1793     {
1794       // setup default callback
1795       myIsGlDebugCtx = Standard_True;
1796       arbDbg->glDebugMessageCallback (debugCallbackWrap, this);
1797       ::glEnable (GL_DEBUG_OUTPUT);
1798       if (caps->contextSyncDebug)
1799       {
1800         // note that some broken implementations (e.g. simulators) might generate error message on this call
1801         ::glEnable (GL_DEBUG_OUTPUT_SYNCHRONOUS);
1802       }
1803     }
1804   }
1805
1806   // load OpenGL ES 3.2 new functions
1807   const bool has32es = IsGlGreaterEqual (3, 2)
1808        && has31es
1809        && hasTexBuffer32
1810        && arbDbg != NULL
1811        && FindProcShort (glBlendBarrier)
1812        && FindProcShort (glCopyImageSubData)
1813        && FindProcShort (glPushDebugGroup)
1814        && FindProcShort (glPopDebugGroup)
1815        && FindProcShort (glObjectLabel)
1816        && FindProcShort (glGetObjectLabel)
1817        && FindProcShort (glObjectPtrLabel)
1818        && FindProcShort (glGetObjectPtrLabel)
1819        && FindProcShort (glGetPointerv)
1820        && FindProcShort (glEnablei)
1821        && FindProcShort (glDisablei)
1822        && FindProcShort (glBlendEquationi)
1823        && FindProcShort (glBlendEquationSeparatei)
1824        && FindProcShort (glBlendFunci)
1825        && FindProcShort (glBlendFuncSeparatei)
1826        && FindProcShort (glColorMaski)
1827        && FindProcShort (glIsEnabledi)
1828        && FindProcShort (glDrawElementsBaseVertex)
1829        && FindProcShort (glDrawRangeElementsBaseVertex)
1830        && FindProcShort (glDrawElementsInstancedBaseVertex)
1831        && FindProcShort (glFramebufferTexture)
1832        && FindProcShort (glPrimitiveBoundingBox)
1833        && FindProcShort (glGetGraphicsResetStatus)
1834        && FindProcShort (glReadnPixels)
1835        && FindProcShort (glGetnUniformfv)
1836        && FindProcShort (glGetnUniformiv)
1837        && FindProcShort (glGetnUniformuiv)
1838        && FindProcShort (glMinSampleShading)
1839        && FindProcShort (glPatchParameteri)
1840        && FindProcShort (glTexParameterIiv)
1841        && FindProcShort (glTexParameterIuiv)
1842        && FindProcShort (glGetTexParameterIiv)
1843        && FindProcShort (glGetTexParameterIuiv)
1844        && FindProcShort (glSamplerParameterIiv)
1845        && FindProcShort (glSamplerParameterIuiv)
1846        && FindProcShort (glGetSamplerParameterIiv)
1847        && FindProcShort (glGetSamplerParameterIuiv)
1848        && FindProcShort (glTexBufferRange)
1849        && FindProcShort (glTexStorage3DMultisample);
1850   if (!has32es)
1851   {
1852     checkWrongVersion (3, 2, aLastFailedProc);
1853   }
1854
1855   extDrawBuffers = CheckExtension ("GL_EXT_draw_buffers") && FindProc ("glDrawBuffersEXT", myFuncs->glDrawBuffers);
1856   arbDrawBuffers = CheckExtension ("GL_ARB_draw_buffers") && FindProc ("glDrawBuffersARB", myFuncs->glDrawBuffers);
1857
1858   if (IsGlGreaterEqual (3, 0) && FindProcShort (glDrawBuffers))
1859   {
1860     hasDrawBuffers = OpenGl_FeatureInCore;
1861   }
1862   else if (extDrawBuffers || arbDrawBuffers)
1863   {
1864     hasDrawBuffers = OpenGl_FeatureInExtensions;
1865   }
1866
1867   hasFloatBuffer     = IsGlGreaterEqual (3, 2) ? OpenGl_FeatureInCore :
1868                        CheckExtension ("GL_EXT_color_buffer_float") ? OpenGl_FeatureInExtensions 
1869                                                                     : OpenGl_FeatureNotAvailable;
1870   hasHalfFloatBuffer = IsGlGreaterEqual (3, 2) ? OpenGl_FeatureInCore :
1871                        CheckExtension ("GL_EXT_color_buffer_half_float") ? OpenGl_FeatureInExtensions 
1872                                                                          : OpenGl_FeatureNotAvailable;
1873
1874   oesSampleVariables = CheckExtension ("GL_OES_sample_variables");
1875   oesStdDerivatives  = CheckExtension ("GL_OES_standard_derivatives");
1876   hasSampleVariables = IsGlGreaterEqual (3, 2) ? OpenGl_FeatureInCore :
1877                        oesSampleVariables ? OpenGl_FeatureInExtensions
1878                                           : OpenGl_FeatureNotAvailable;
1879   hasGlslBitwiseOps = IsGlGreaterEqual (3, 0)
1880                     ? OpenGl_FeatureInCore
1881                     : OpenGl_FeatureNotAvailable;
1882   // without hasHighp, dFdx/dFdy precision is considered too low for flat shading (visual artifacts)
1883   hasFlatShading = IsGlGreaterEqual (3, 0)
1884                  ? OpenGl_FeatureInCore
1885                   : (oesStdDerivatives && hasHighp
1886                    ? OpenGl_FeatureInExtensions
1887                    : OpenGl_FeatureNotAvailable);
1888   if (!IsGlGreaterEqual (3, 1)
1889     && myVendor.Search("qualcomm") != -1)
1890   {
1891     // dFdx/dFdy are completely broken on tested Adreno devices with versions below OpenGl ES 3.1
1892     hasFlatShading = OpenGl_FeatureNotAvailable;
1893   }
1894
1895   hasGeometryStage = IsGlGreaterEqual (3, 2)
1896                    ? OpenGl_FeatureInCore
1897                    : (CheckExtension ("GL_EXT_geometry_shader") && CheckExtension ("GL_EXT_shader_io_blocks")
1898                      ? OpenGl_FeatureInExtensions
1899                      : OpenGl_FeatureNotAvailable);
1900 #else
1901
1902   myTexClamp = IsGlGreaterEqual (1, 2) ? GL_CLAMP_TO_EDGE : GL_CLAMP;
1903
1904   hasTexRGBA8 = Standard_True;
1905   hasTexSRGB       = IsGlGreaterEqual (2, 1);
1906   hasFboSRGB       = IsGlGreaterEqual (2, 1);
1907   hasSRGBControl   = hasFboSRGB;
1908   arbDrawBuffers   = CheckExtension ("GL_ARB_draw_buffers");
1909   arbNPTW          = CheckExtension ("GL_ARB_texture_non_power_of_two");
1910   arbTexFloat      = IsGlGreaterEqual (3, 0)
1911                   || CheckExtension ("GL_ARB_texture_float");
1912   hasTexFloatLinear = arbTexFloat;
1913   arbSampleShading = CheckExtension ("GL_ARB_sample_shading");
1914   extBgra          = IsGlGreaterEqual (1, 2)
1915                   || CheckExtension ("GL_EXT_bgra");
1916   extAnis          = CheckExtension ("GL_EXT_texture_filter_anisotropic");
1917   extPDS           = CheckExtension ("GL_EXT_packed_depth_stencil");
1918   atiMem           = CheckExtension ("GL_ATI_meminfo");
1919   nvxMem           = CheckExtension ("GL_NVX_gpu_memory_info");
1920
1921   if (extBgra)
1922   {
1923     mySupportedFormats->Add (Image_PixMap::ImgBGR);
1924     mySupportedFormats->Add (Image_PixMap::ImgBGR32);
1925     mySupportedFormats->Add (Image_PixMap::ImgBGRA);
1926   }
1927
1928   hasDrawBuffers = IsGlGreaterEqual (2, 0) ? OpenGl_FeatureInCore :
1929                    arbDrawBuffers ? OpenGl_FeatureInExtensions 
1930                                   : OpenGl_FeatureNotAvailable;
1931
1932   hasGlslBitwiseOps = IsGlGreaterEqual (3, 0)
1933                     ? OpenGl_FeatureInCore
1934                     : CheckExtension ("GL_EXT_gpu_shader4")
1935                      ? OpenGl_FeatureInExtensions
1936                      : OpenGl_FeatureNotAvailable;
1937
1938   hasFloatBuffer = hasHalfFloatBuffer =  IsGlGreaterEqual (3, 0) ? OpenGl_FeatureInCore :
1939                                          CheckExtension ("GL_ARB_color_buffer_float") ? OpenGl_FeatureInExtensions
1940                                                                                       : OpenGl_FeatureNotAvailable;
1941
1942   hasGeometryStage = IsGlGreaterEqual (3, 2)
1943                    ? OpenGl_FeatureInCore
1944                    : OpenGl_FeatureNotAvailable;
1945
1946   hasSampleVariables = IsGlGreaterEqual (4, 0) ? OpenGl_FeatureInCore :
1947                         arbSampleShading ? OpenGl_FeatureInExtensions
1948                                          : OpenGl_FeatureNotAvailable;
1949
1950   GLint aStereo = GL_FALSE;
1951   glGetIntegerv (GL_STEREO, &aStereo);
1952   myIsStereoBuffers = aStereo == 1;
1953
1954   // get number of maximum clipping planes
1955   glGetIntegerv (GL_MAX_CLIP_PLANES,  &myMaxClipPlanes);
1956 #endif
1957
1958   if (hasDrawBuffers)
1959   {
1960     glGetIntegerv (GL_MAX_DRAW_BUFFERS,      &myMaxDrawBuffers);
1961     glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &myMaxColorAttachments);
1962     if (myDrawBuffers.Length() < myMaxDrawBuffers)
1963     {
1964       myDrawBuffers.Resize (0, myMaxDrawBuffers - 1, false);
1965     }
1966   }
1967
1968   glGetIntegerv (GL_MAX_TEXTURE_SIZE, &myMaxTexDim);
1969 #if !defined(GL_ES_VERSION_2_0)
1970   if (IsGlGreaterEqual (1, 3) && core11 != NULL)
1971   {
1972     // this is a maximum of texture units for FFP functionality,
1973     // usually smaller than combined texture units available for GLSL
1974     glGetIntegerv (GL_MAX_TEXTURE_UNITS, &myMaxTexUnitsFFP);
1975     myMaxTexCombined = myMaxTexUnitsFFP;
1976   }
1977 #endif
1978   if (IsGlGreaterEqual (2, 0))
1979   {
1980     glGetIntegerv (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &myMaxTexCombined);
1981   }
1982   mySpriteTexUnit = myMaxTexCombined >= 2
1983                   ? Graphic3d_TextureUnit_PointSprite
1984                   : Graphic3d_TextureUnit_0;
1985
1986   GLint aMaxVPortSize[2] = {0, 0};
1987   glGetIntegerv (GL_MAX_VIEWPORT_DIMS, aMaxVPortSize);
1988   myMaxDumpSizeX = Min (aMaxVPortSize[0], myMaxTexDim);
1989   myMaxDumpSizeY = Min (aMaxVPortSize[1], myMaxTexDim);
1990   if (myVendor == "intel")
1991   {
1992     // Intel drivers have known bug with empty dump for images with width>=5462
1993     myMaxDumpSizeX = Min (myMaxDumpSizeX, 4096);
1994   }
1995
1996   if (extAnis)
1997   {
1998     glGetIntegerv (GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &myAnisoMax);
1999   }
2000
2001   myClippingState.Init();
2002
2003 #if !defined(GL_ES_VERSION_2_0)
2004
2005   bool has12 = false;
2006   bool has13 = false;
2007   bool has14 = false;
2008   bool has15 = false;
2009   bool has20 = false;
2010   bool has21 = false;
2011   bool has30 = false;
2012   bool has31 = false;
2013   bool has32 = false;
2014   bool has33 = false;
2015   bool has40 = false;
2016   bool has41 = false;
2017   bool has42 = false;
2018   bool has43 = false;
2019   bool has44 = false;
2020   bool has45 = false;
2021
2022   // retrieve platform-dependent extensions
2023 #if defined(HAVE_EGL)
2024   //
2025 #elif defined(_WIN32)
2026   if (FindProcShort (wglGetExtensionsStringARB))
2027   {
2028     const char* aWglExts = myFuncs->wglGetExtensionsStringARB (wglGetCurrentDC());
2029     if (CheckExtension (aWglExts, "WGL_EXT_swap_control"))
2030     {
2031       FindProcShort (wglSwapIntervalEXT);
2032     }
2033     if (CheckExtension (aWglExts, "WGL_ARB_pixel_format"))
2034     {
2035       FindProcShort (wglChoosePixelFormatARB);
2036     }
2037     if (CheckExtension (aWglExts, "WGL_ARB_create_context_profile"))
2038     {
2039       FindProcShort (wglCreateContextAttribsARB);
2040     }
2041     if (CheckExtension (aWglExts, "WGL_NV_DX_interop"))
2042     {
2043       FindProcShort (wglDXSetResourceShareHandleNV);
2044       FindProcShort (wglDXOpenDeviceNV);
2045       FindProcShort (wglDXCloseDeviceNV);
2046       FindProcShort (wglDXRegisterObjectNV);
2047       FindProcShort (wglDXUnregisterObjectNV);
2048       FindProcShort (wglDXObjectAccessNV);
2049       FindProcShort (wglDXLockObjectsNV);
2050       FindProcShort (wglDXUnlockObjectsNV);
2051     }
2052     if (CheckExtension (aWglExts, "WGL_AMD_gpu_association"))
2053     {
2054       FindProcShort (wglGetGPUIDsAMD);
2055       FindProcShort (wglGetGPUInfoAMD);
2056       FindProcShort (wglGetContextGPUIDAMD);
2057     }
2058   }
2059 #elif defined(__APPLE__)
2060     //
2061 #else
2062     const char* aGlxExts = ::glXQueryExtensionsString ((Display* )myDisplay, DefaultScreen ((Display* )myDisplay));
2063     if (CheckExtension (aGlxExts, "GLX_EXT_swap_control"))
2064     {
2065       FindProcShort (glXSwapIntervalEXT);
2066     }
2067     if (CheckExtension (aGlxExts, "GLX_SGI_swap_control"))
2068     {
2069       FindProcShort (glXSwapIntervalSGI);
2070     }
2071     if (CheckExtension (aGlxExts, "GLX_MESA_query_renderer"))
2072     {
2073       FindProcShort (glXQueryRendererIntegerMESA);
2074       FindProcShort (glXQueryCurrentRendererIntegerMESA);
2075       FindProcShort (glXQueryRendererStringMESA);
2076       FindProcShort (glXQueryCurrentRendererStringMESA);
2077     }
2078     //extSwapTear = CheckExtension (aGlxExts, "GLX_EXT_swap_control_tear");
2079 #endif
2080
2081   // load OpenGL 1.2 new functions
2082   has12 = IsGlGreaterEqual (1, 2)
2083        && FindProcShort (glBlendColor)
2084        && FindProcShort (glBlendEquation)
2085        && FindProcShort (glDrawRangeElements)
2086        && FindProcShort (glTexImage3D)
2087        && FindProcShort (glTexSubImage3D)
2088        && FindProcShort (glCopyTexSubImage3D);
2089   if (!has12)
2090   {
2091     checkWrongVersion (1, 2, aLastFailedProc);
2092   }
2093
2094   // load OpenGL 1.3 new functions
2095   has13 = IsGlGreaterEqual (1, 3)
2096        && FindProcShort (glActiveTexture)
2097        && FindProcShort (glSampleCoverage)
2098        && FindProcShort (glCompressedTexImage3D)
2099        && FindProcShort (glCompressedTexImage2D)
2100        && FindProcShort (glCompressedTexImage1D)
2101        && FindProcShort (glCompressedTexSubImage3D)
2102        && FindProcShort (glCompressedTexSubImage2D)
2103        && FindProcShort (glCompressedTexSubImage1D)
2104        && FindProcShort (glGetCompressedTexImage);
2105
2106   if (!isCoreProfile)
2107   {
2108     has13 = has13
2109        && FindProcShort (glClientActiveTexture)
2110        && FindProcShort (glMultiTexCoord1d)
2111        && FindProcShort (glMultiTexCoord1dv)
2112        && FindProcShort (glMultiTexCoord1f)
2113        && FindProcShort (glMultiTexCoord1fv)
2114        && FindProcShort (glMultiTexCoord1i)
2115        && FindProcShort (glMultiTexCoord1iv)
2116        && FindProcShort (glMultiTexCoord1s)
2117        && FindProcShort (glMultiTexCoord1sv)
2118        && FindProcShort (glMultiTexCoord2d)
2119        && FindProcShort (glMultiTexCoord2dv)
2120        && FindProcShort (glMultiTexCoord2f)
2121        && FindProcShort (glMultiTexCoord2fv)
2122        && FindProcShort (glMultiTexCoord2i)
2123        && FindProcShort (glMultiTexCoord2iv)
2124        && FindProcShort (glMultiTexCoord2s)
2125        && FindProcShort (glMultiTexCoord2sv)
2126        && FindProcShort (glMultiTexCoord3d)
2127        && FindProcShort (glMultiTexCoord3dv)
2128        && FindProcShort (glMultiTexCoord3f)
2129        && FindProcShort (glMultiTexCoord3fv)
2130        && FindProcShort (glMultiTexCoord3i)
2131        && FindProcShort (glMultiTexCoord3iv)
2132        && FindProcShort (glMultiTexCoord3s)
2133        && FindProcShort (glMultiTexCoord3sv)
2134        && FindProcShort (glMultiTexCoord4d)
2135        && FindProcShort (glMultiTexCoord4dv)
2136        && FindProcShort (glMultiTexCoord4f)
2137        && FindProcShort (glMultiTexCoord4fv)
2138        && FindProcShort (glMultiTexCoord4i)
2139        && FindProcShort (glMultiTexCoord4iv)
2140        && FindProcShort (glMultiTexCoord4s)
2141        && FindProcShort (glMultiTexCoord4sv)
2142        && FindProcShort (glLoadTransposeMatrixf)
2143        && FindProcShort (glLoadTransposeMatrixd)
2144        && FindProcShort (glMultTransposeMatrixf)
2145        && FindProcShort (glMultTransposeMatrixd);
2146   }
2147   if (!has13)
2148   {
2149     checkWrongVersion (1, 3, aLastFailedProc);
2150   }
2151
2152   // load OpenGL 1.4 new functions
2153   has14 = IsGlGreaterEqual (1, 4)
2154        && FindProcShort (glBlendFuncSeparate)
2155        && FindProcShort (glMultiDrawArrays)
2156        && FindProcShort (glMultiDrawElements)
2157        && FindProcShort (glPointParameterf)
2158        && FindProcShort (glPointParameterfv)
2159        && FindProcShort (glPointParameteri)
2160        && FindProcShort (glPointParameteriv);
2161   if (!has14)
2162   {
2163     checkWrongVersion (1, 4, aLastFailedProc);
2164   }
2165
2166   // load OpenGL 1.5 new functions
2167   has15 = IsGlGreaterEqual (1, 5)
2168        && FindProcShort (glGenQueries)
2169        && FindProcShort (glDeleteQueries)
2170        && FindProcShort (glIsQuery)
2171        && FindProcShort (glBeginQuery)
2172        && FindProcShort (glEndQuery)
2173        && FindProcShort (glGetQueryiv)
2174        && FindProcShort (glGetQueryObjectiv)
2175        && FindProcShort (glGetQueryObjectuiv)
2176        && FindProcShort (glBindBuffer)
2177        && FindProcShort (glDeleteBuffers)
2178        && FindProcShort (glGenBuffers)
2179        && FindProcShort (glIsBuffer)
2180        && FindProcShort (glBufferData)
2181        && FindProcShort (glBufferSubData)
2182        && FindProcShort (glGetBufferSubData)
2183        && FindProcShort (glMapBuffer)
2184        && FindProcShort (glUnmapBuffer)
2185        && FindProcShort (glGetBufferParameteriv)
2186        && FindProcShort (glGetBufferPointerv);
2187   if (has15)
2188   {
2189     if (!isCoreProfile)
2190     {
2191       core15 = (OpenGl_GlCore15* )(&(*myFuncs));
2192     }
2193     core15fwd = (OpenGl_GlCore15Fwd* )(&(*myFuncs));
2194     hasGetBufferData = true;
2195   }
2196   else
2197   {
2198     checkWrongVersion (1, 5, aLastFailedProc);
2199   }
2200
2201   // load OpenGL 2.0 new functions
2202   has20 = IsGlGreaterEqual (2, 0)
2203        && FindProcShort (glBlendEquationSeparate)
2204        && FindProcShort (glDrawBuffers)
2205        && FindProcShort (glStencilOpSeparate)
2206        && FindProcShort (glStencilFuncSeparate)
2207        && FindProcShort (glStencilMaskSeparate)
2208        && FindProcShort (glAttachShader)
2209        && FindProcShort (glBindAttribLocation)
2210        && FindProcShort (glCompileShader)
2211        && FindProcShort (glCreateProgram)
2212        && FindProcShort (glCreateShader)
2213        && FindProcShort (glDeleteProgram)
2214        && FindProcShort (glDeleteShader)
2215        && FindProcShort (glDetachShader)
2216        && FindProcShort (glDisableVertexAttribArray)
2217        && FindProcShort (glEnableVertexAttribArray)
2218        && FindProcShort (glGetActiveAttrib)
2219        && FindProcShort (glGetActiveUniform)
2220        && FindProcShort (glGetAttachedShaders)
2221        && FindProcShort (glGetAttribLocation)
2222        && FindProcShort (glGetProgramiv)
2223        && FindProcShort (glGetProgramInfoLog)
2224        && FindProcShort (glGetShaderiv)
2225        && FindProcShort (glGetShaderInfoLog)
2226        && FindProcShort (glGetShaderSource)
2227        && FindProcShort (glGetUniformLocation)
2228        && FindProcShort (glGetUniformfv)
2229        && FindProcShort (glGetUniformiv)
2230        && FindProcShort (glGetVertexAttribdv)
2231        && FindProcShort (glGetVertexAttribfv)
2232        && FindProcShort (glGetVertexAttribiv)
2233        && FindProcShort (glGetVertexAttribPointerv)
2234        && FindProcShort (glIsProgram)
2235        && FindProcShort (glIsShader)
2236        && FindProcShort (glLinkProgram)
2237        && FindProcShort (glShaderSource)
2238        && FindProcShort (glUseProgram)
2239        && FindProcShort (glUniform1f)
2240        && FindProcShort (glUniform2f)
2241        && FindProcShort (glUniform3f)
2242        && FindProcShort (glUniform4f)
2243        && FindProcShort (glUniform1i)
2244        && FindProcShort (glUniform2i)
2245        && FindProcShort (glUniform3i)
2246        && FindProcShort (glUniform4i)
2247        && FindProcShort (glUniform1fv)
2248        && FindProcShort (glUniform2fv)
2249        && FindProcShort (glUniform3fv)
2250        && FindProcShort (glUniform4fv)
2251        && FindProcShort (glUniform1iv)
2252        && FindProcShort (glUniform2iv)
2253        && FindProcShort (glUniform3iv)
2254        && FindProcShort (glUniform4iv)
2255        && FindProcShort (glUniformMatrix2fv)
2256        && FindProcShort (glUniformMatrix3fv)
2257        && FindProcShort (glUniformMatrix4fv)
2258        && FindProcShort (glValidateProgram)
2259        && FindProcShort (glVertexAttrib1d)
2260        && FindProcShort (glVertexAttrib1dv)
2261        && FindProcShort (glVertexAttrib1f)
2262        && FindProcShort (glVertexAttrib1fv)
2263        && FindProcShort (glVertexAttrib1s)
2264        && FindProcShort (glVertexAttrib1sv)
2265        && FindProcShort (glVertexAttrib2d)
2266        && FindProcShort (glVertexAttrib2dv)
2267        && FindProcShort (glVertexAttrib2f)
2268        && FindProcShort (glVertexAttrib2fv)
2269        && FindProcShort (glVertexAttrib2s)
2270        && FindProcShort (glVertexAttrib2sv)
2271        && FindProcShort (glVertexAttrib3d)
2272        && FindProcShort (glVertexAttrib3dv)
2273        && FindProcShort (glVertexAttrib3f)
2274        && FindProcShort (glVertexAttrib3fv)
2275        && FindProcShort (glVertexAttrib3s)
2276        && FindProcShort (glVertexAttrib3sv)
2277        && FindProcShort (glVertexAttrib4Nbv)
2278        && FindProcShort (glVertexAttrib4Niv)
2279        && FindProcShort (glVertexAttrib4Nsv)
2280        && FindProcShort (glVertexAttrib4Nub)
2281        && FindProcShort (glVertexAttrib4Nubv)
2282        && FindProcShort (glVertexAttrib4Nuiv)
2283        && FindProcShort (glVertexAttrib4Nusv)
2284        && FindProcShort (glVertexAttrib4bv)
2285        && FindProcShort (glVertexAttrib4d)
2286        && FindProcShort (glVertexAttrib4dv)
2287        && FindProcShort (glVertexAttrib4f)
2288        && FindProcShort (glVertexAttrib4fv)
2289        && FindProcShort (glVertexAttrib4iv)
2290        && FindProcShort (glVertexAttrib4s)
2291        && FindProcShort (glVertexAttrib4sv)
2292        && FindProcShort (glVertexAttrib4ubv)
2293        && FindProcShort (glVertexAttrib4uiv)
2294        && FindProcShort (glVertexAttrib4usv)
2295        && FindProcShort (glVertexAttribPointer);
2296   if (has20)
2297   {
2298     const char* aGlslVer = (const char* )::glGetString (GL_SHADING_LANGUAGE_VERSION);
2299     if (aGlslVer == NULL
2300     || *aGlslVer == '\0')
2301     {
2302       // broken context has been detected
2303       PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
2304                    TCollection_AsciiString("Error! OpenGL context reports version ")
2305                    + myGlVerMajor  + "." + myGlVerMinor + " but reports wrong GLSL version");
2306       myGlVerMajor = 1;
2307       myGlVerMinor = 5;
2308     }
2309     else
2310     {
2311       if (!isCoreProfile)
2312       {
2313         core20  = (OpenGl_GlCore20*    )(&(*myFuncs));
2314       }
2315       core20fwd = (OpenGl_GlCore20Fwd* )(&(*myFuncs));
2316     }
2317   }
2318   else
2319   {
2320     checkWrongVersion (2, 0, aLastFailedProc);
2321   }
2322
2323   // load OpenGL 2.1 new functions
2324   has21 = IsGlGreaterEqual (2, 1)
2325        && FindProcShort (glUniformMatrix2x3fv)
2326        && FindProcShort (glUniformMatrix3x2fv)
2327        && FindProcShort (glUniformMatrix2x4fv)
2328        && FindProcShort (glUniformMatrix4x2fv)
2329        && FindProcShort (glUniformMatrix3x4fv)
2330        && FindProcShort (glUniformMatrix4x3fv);
2331   if (!has21)
2332   {
2333     checkWrongVersion (2, 1, aLastFailedProc);
2334   }
2335
2336   // load GL_ARB_framebuffer_object (added to OpenGL 3.0 core)
2337   const bool hasFBO = (IsGlGreaterEqual (3, 0) || CheckExtension ("GL_ARB_framebuffer_object"))
2338        && FindProcShort (glIsRenderbuffer)
2339        && FindProcShort (glBindRenderbuffer)
2340        && FindProcShort (glDeleteRenderbuffers)
2341        && FindProcShort (glGenRenderbuffers)
2342        && FindProcShort (glRenderbufferStorage)
2343        && FindProcShort (glGetRenderbufferParameteriv)
2344        && FindProcShort (glIsFramebuffer)
2345        && FindProcShort (glBindFramebuffer)
2346        && FindProcShort (glDeleteFramebuffers)
2347        && FindProcShort (glGenFramebuffers)
2348        && FindProcShort (glCheckFramebufferStatus)
2349        && FindProcShort (glFramebufferTexture1D)
2350        && FindProcShort (glFramebufferTexture2D)
2351        && FindProcShort (glFramebufferTexture3D)
2352        && FindProcShort (glFramebufferRenderbuffer)
2353        && FindProcShort (glGetFramebufferAttachmentParameteriv)
2354        && FindProcShort (glGenerateMipmap)
2355        && FindProcShort (glBlitFramebuffer)
2356        && FindProcShort (glRenderbufferStorageMultisample)
2357        && FindProcShort (glFramebufferTextureLayer);
2358
2359   // load GL_ARB_vertex_array_object (added to OpenGL 3.0 core)
2360   const bool hasVAO = (IsGlGreaterEqual (3, 0) || CheckExtension ("GL_ARB_vertex_array_object"))
2361        && FindProcShort (glBindVertexArray)
2362        && FindProcShort (glDeleteVertexArrays)
2363        && FindProcShort (glGenVertexArrays)
2364        && FindProcShort (glIsVertexArray);
2365
2366   // load GL_ARB_map_buffer_range (added to OpenGL 3.0 core)
2367   const bool hasMapBufferRange = (IsGlGreaterEqual (3, 0) || CheckExtension ("GL_ARB_map_buffer_range"))
2368        && FindProcShort (glMapBufferRange)
2369        && FindProcShort (glFlushMappedBufferRange);
2370
2371   // load OpenGL 3.0 new functions
2372   has30 = IsGlGreaterEqual (3, 0)
2373        && hasFBO
2374        && hasVAO
2375        && hasMapBufferRange
2376        && FindProcShort (glColorMaski)
2377        && FindProcShort (glGetBooleani_v)
2378        && FindProcShort (glGetIntegeri_v)
2379        && FindProcShort (glEnablei)
2380        && FindProcShort (glDisablei)
2381        && FindProcShort (glIsEnabledi)
2382        && FindProcShort (glBeginTransformFeedback)
2383        && FindProcShort (glEndTransformFeedback)
2384        && FindProcShort (glBindBufferRange)
2385        && FindProcShort (glBindBufferBase)
2386        && FindProcShort (glTransformFeedbackVaryings)
2387        && FindProcShort (glGetTransformFeedbackVarying)
2388        && FindProcShort (glClampColor)
2389        && FindProcShort (glBeginConditionalRender)
2390        && FindProcShort (glEndConditionalRender)
2391        && FindProcShort (glVertexAttribIPointer)
2392        && FindProcShort (glGetVertexAttribIiv)
2393        && FindProcShort (glGetVertexAttribIuiv)
2394        && FindProcShort (glVertexAttribI1i)
2395        && FindProcShort (glVertexAttribI2i)
2396        && FindProcShort (glVertexAttribI3i)
2397        && FindProcShort (glVertexAttribI4i)
2398        && FindProcShort (glVertexAttribI1ui)
2399        && FindProcShort (glVertexAttribI2ui)
2400        && FindProcShort (glVertexAttribI3ui)
2401        && FindProcShort (glVertexAttribI4ui)
2402        && FindProcShort (glVertexAttribI1iv)
2403        && FindProcShort (glVertexAttribI2iv)
2404        && FindProcShort (glVertexAttribI3iv)
2405        && FindProcShort (glVertexAttribI4iv)
2406        && FindProcShort (glVertexAttribI1uiv)
2407        && FindProcShort (glVertexAttribI2uiv)
2408        && FindProcShort (glVertexAttribI3uiv)
2409        && FindProcShort (glVertexAttribI4uiv)
2410        && FindProcShort (glVertexAttribI4bv)
2411        && FindProcShort (glVertexAttribI4sv)
2412        && FindProcShort (glVertexAttribI4ubv)
2413        && FindProcShort (glVertexAttribI4usv)
2414        && FindProcShort (glGetUniformuiv)
2415        && FindProcShort (glBindFragDataLocation)
2416        && FindProcShort (glGetFragDataLocation)
2417        && FindProcShort (glUniform1ui)
2418        && FindProcShort (glUniform2ui)
2419        && FindProcShort (glUniform3ui)
2420        && FindProcShort (glUniform4ui)
2421        && FindProcShort (glUniform1uiv)
2422        && FindProcShort (glUniform2uiv)
2423        && FindProcShort (glUniform3uiv)
2424        && FindProcShort (glUniform4uiv)
2425        && FindProcShort (glTexParameterIiv)
2426        && FindProcShort (glTexParameterIuiv)
2427        && FindProcShort (glGetTexParameterIiv)
2428        && FindProcShort (glGetTexParameterIuiv)
2429        && FindProcShort (glClearBufferiv)
2430        && FindProcShort (glClearBufferuiv)
2431        && FindProcShort (glClearBufferfv)
2432        && FindProcShort (glClearBufferfi)
2433        && FindProcShort (glGetStringi);
2434   if (!has30)
2435   {
2436     checkWrongVersion (3, 0, aLastFailedProc);
2437   }
2438
2439   // load GL_ARB_uniform_buffer_object (added to OpenGL 3.1 core)
2440   const bool hasUBO = (IsGlGreaterEqual (3, 1) || CheckExtension ("GL_ARB_uniform_buffer_object"))
2441        && FindProcShort (glGetUniformIndices)
2442        && FindProcShort (glGetActiveUniformsiv)
2443        && FindProcShort (glGetActiveUniformName)
2444        && FindProcShort (glGetUniformBlockIndex)
2445        && FindProcShort (glGetActiveUniformBlockiv)
2446        && FindProcShort (glGetActiveUniformBlockName)
2447        && FindProcShort (glUniformBlockBinding);
2448
2449   // load GL_ARB_copy_buffer (added to OpenGL 3.1 core)
2450   const bool hasCopyBufSubData = (IsGlGreaterEqual (3, 1) || CheckExtension ("GL_ARB_copy_buffer"))
2451        && FindProcShort (glCopyBufferSubData);
2452
2453   if (has30)
2454   {
2455     // NPOT textures are required by OpenGL 2.0 specifications
2456     // but doesn't hardware accelerated by some ancient OpenGL 2.1 hardware (GeForce FX, RadeOn 9700 etc.)
2457     arbNPTW  = Standard_True;
2458     arbTexRG = Standard_True;
2459
2460     if (!isCoreProfile)
2461     {
2462       core30 = (OpenGl_GlCore30* )(&(*myFuncs));
2463     }
2464     core30fwd = (OpenGl_GlCore30Fwd* )(&(*myFuncs));
2465   }
2466
2467   // load OpenGL 3.1 new functions
2468   has31 = IsGlGreaterEqual (3, 1)
2469        && hasUBO
2470        && hasCopyBufSubData
2471        && FindProcShort (glDrawArraysInstanced)
2472        && FindProcShort (glDrawElementsInstanced)
2473        && FindProcShort (glTexBuffer)
2474        && FindProcShort (glPrimitiveRestartIndex);
2475   if (has31)
2476   {
2477     arbTBO = (OpenGl_ArbTBO* )(&(*myFuncs));
2478     arbIns = (OpenGl_ArbIns* )(&(*myFuncs));
2479   }
2480   else
2481   {
2482     checkWrongVersion (3, 1, aLastFailedProc);
2483
2484     // initialize TBO extension (ARB)
2485     if (CheckExtension ("GL_ARB_texture_buffer_object")
2486      && FindProc ("glTexBufferARB", myFuncs->glTexBuffer))
2487     {
2488       arbTBO = (OpenGl_ArbTBO* )(&(*myFuncs));
2489     }
2490
2491     // initialize hardware instancing extension (ARB)
2492     if (CheckExtension ("GL_ARB_draw_instanced")
2493      && FindProc ("glDrawArraysInstancedARB",   myFuncs->glDrawArraysInstanced)
2494      && FindProc ("glDrawElementsInstancedARB", myFuncs->glDrawElementsInstanced))
2495     {
2496       arbIns = (OpenGl_ArbIns* )(&(*myFuncs));
2497     }
2498   }
2499
2500   arbTboRGB32 = CheckExtension ("GL_ARB_texture_buffer_object_rgb32");
2501
2502   // load GL_ARB_draw_elements_base_vertex (added to OpenGL 3.2 core)
2503   const bool hasDrawElemsBaseVert = (IsGlGreaterEqual (3, 2) || CheckExtension ("GL_ARB_draw_elements_base_vertex"))
2504        && FindProcShort (glDrawElementsBaseVertex)
2505        && FindProcShort (glDrawRangeElementsBaseVertex)
2506        && FindProcShort (glDrawElementsInstancedBaseVertex)
2507        && FindProcShort (glMultiDrawElementsBaseVertex);
2508
2509   // load GL_ARB_provoking_vertex (added to OpenGL 3.2 core)
2510   const bool hasProvokingVert = (IsGlGreaterEqual (3, 2) || CheckExtension ("GL_ARB_provoking_vertex"))
2511        && FindProcShort (glProvokingVertex);
2512
2513   // load GL_ARB_sync (added to OpenGL 3.2 core)
2514   const bool hasSync = (IsGlGreaterEqual (3, 2) || CheckExtension ("GL_ARB_sync"))
2515        && FindProcShort (glFenceSync)
2516        && FindProcShort (glIsSync)
2517        && FindProcShort (glDeleteSync)
2518        && FindProcShort (glClientWaitSync)
2519        && FindProcShort (glWaitSync)
2520        && FindProcShort (glGetInteger64v)
2521        && FindProcShort (glGetSynciv);
2522
2523   // load GL_ARB_texture_multisample (added to OpenGL 3.2 core)
2524   const bool hasTextureMultisample = (IsGlGreaterEqual (3, 2) || CheckExtension ("GL_ARB_texture_multisample"))
2525        && FindProcShort (glTexImage2DMultisample)
2526        && FindProcShort (glTexImage3DMultisample)
2527        && FindProcShort (glGetMultisamplefv)
2528        && FindProcShort (glSampleMaski);
2529
2530   // load OpenGL 3.2 new functions
2531   has32 = IsGlGreaterEqual (3, 2)
2532        && hasDrawElemsBaseVert
2533        && hasProvokingVert
2534        && hasSync
2535        && hasTextureMultisample
2536        && FindProcShort (glGetInteger64i_v)
2537        && FindProcShort (glGetBufferParameteri64v)
2538        && FindProcShort (glFramebufferTexture);
2539   if (has32)
2540   {
2541     core32 = (OpenGl_GlCore32* )(&(*myFuncs));
2542     if (isCoreProfile)
2543     {
2544       core32->glGenVertexArrays (1, &myDefaultVao);
2545     }
2546     else
2547     {
2548       core32back = (OpenGl_GlCore32Back* )(&(*myFuncs));
2549     }
2550     ::glGetIntegerv (GL_MAX_SAMPLES, &myMaxMsaaSamples);
2551   }
2552   else
2553   {
2554     checkWrongVersion (3, 2, aLastFailedProc);
2555   }
2556
2557   // load GL_ARB_blend_func_extended (added to OpenGL 3.3 core)
2558   const bool hasBlendFuncExtended = (IsGlGreaterEqual (3, 3) || CheckExtension ("GL_ARB_blend_func_extended"))
2559        && FindProcShort (glBindFragDataLocationIndexed)
2560        && FindProcShort (glGetFragDataIndex);
2561
2562   // load GL_ARB_sampler_objects (added to OpenGL 3.3 core)
2563   const bool hasSamplerObjects = (IsGlGreaterEqual (3, 3) || CheckExtension ("GL_ARB_sampler_objects"))
2564        && FindProcShort (glGenSamplers)
2565        && FindProcShort (glDeleteSamplers)
2566        && FindProcShort (glIsSampler)
2567        && FindProcShort (glBindSampler)
2568        && FindProcShort (glSamplerParameteri)
2569        && FindProcShort (glSamplerParameteriv)
2570        && FindProcShort (glSamplerParameterf)
2571        && FindProcShort (glSamplerParameterfv)
2572        && FindProcShort (glSamplerParameterIiv)
2573        && FindProcShort (glSamplerParameterIuiv)
2574        && FindProcShort (glGetSamplerParameteriv)
2575        && FindProcShort (glGetSamplerParameterIiv)
2576        && FindProcShort (glGetSamplerParameterfv)
2577        && FindProcShort (glGetSamplerParameterIuiv);
2578   if (hasSamplerObjects)
2579   {
2580     arbSamplerObject = (OpenGl_ArbSamplerObject* )(&(*myFuncs));
2581   }
2582
2583   // load GL_ARB_timer_query (added to OpenGL 3.3 core)
2584   const bool hasTimerQuery = (IsGlGreaterEqual (3, 3) || CheckExtension ("GL_ARB_timer_query"))
2585        && FindProcShort (glQueryCounter)
2586        && FindProcShort (glGetQueryObjecti64v)
2587        && FindProcShort (glGetQueryObjectui64v);
2588
2589   // load GL_ARB_vertex_type_2_10_10_10_rev (added to OpenGL 3.3 core)
2590   const bool hasVertType21010101rev = (IsGlGreaterEqual (3, 3) || CheckExtension ("GL_ARB_vertex_type_2_10_10_10_rev"))
2591        && FindProcShort (glVertexAttribP1ui)
2592        && FindProcShort (glVertexAttribP1uiv)
2593        && FindProcShort (glVertexAttribP2ui)
2594        && FindProcShort (glVertexAttribP2uiv)
2595        && FindProcShort (glVertexAttribP3ui)
2596        && FindProcShort (glVertexAttribP3uiv)
2597        && FindProcShort (glVertexAttribP4ui)
2598        && FindProcShort (glVertexAttribP4uiv);
2599
2600   if ( hasVertType21010101rev
2601    && !isCoreProfile)
2602   {
2603     // load deprecated functions
2604     const bool hasVertType21010101revExt =
2605           FindProcShort (glVertexP2ui)
2606        && FindProcShort (glVertexP2uiv)
2607        && FindProcShort (glVertexP3ui)
2608        && FindProcShort (glVertexP3uiv)
2609        && FindProcShort (glVertexP4ui)
2610        && FindProcShort (glVertexP4uiv)
2611        && FindProcShort (glTexCoordP1ui)
2612        && FindProcShort (glTexCoordP1uiv)
2613        && FindProcShort (glTexCoordP2ui)
2614        && FindProcShort (glTexCoordP2uiv)
2615        && FindProcShort (glTexCoordP3ui)
2616        && FindProcShort (glTexCoordP3uiv)
2617        && FindProcShort (glTexCoordP4ui)
2618        && FindProcShort (glTexCoordP4uiv)
2619        && FindProcShort (glMultiTexCoordP1ui)
2620        && FindProcShort (glMultiTexCoordP1uiv)
2621        && FindProcShort (glMultiTexCoordP2ui)
2622        && FindProcShort (glMultiTexCoordP2uiv)
2623        && FindProcShort (glMultiTexCoordP3ui)
2624        && FindProcShort (glMultiTexCoordP3uiv)
2625        && FindProcShort (glMultiTexCoordP4ui)
2626        && FindProcShort (glMultiTexCoordP4uiv)
2627        && FindProcShort (glNormalP3ui)
2628        && FindProcShort (glNormalP3uiv)
2629        && FindProcShort (glColorP3ui)
2630        && FindProcShort (glColorP3uiv)
2631        && FindProcShort (glColorP4ui)
2632        && FindProcShort (glColorP4uiv)
2633        && FindProcShort (glSecondaryColorP3ui)
2634        && FindProcShort (glSecondaryColorP3uiv);
2635     (void )hasVertType21010101revExt;
2636   }
2637
2638   // load OpenGL 3.3 extra functions
2639   has33 = IsGlGreaterEqual (3, 3)
2640        && hasBlendFuncExtended
2641        && hasSamplerObjects
2642        && hasTimerQuery
2643        && hasVertType21010101rev
2644        && FindProcShort (glVertexAttribDivisor);
2645   if (has33)
2646   {
2647     core33 = (OpenGl_GlCore33* )(&(*myFuncs));
2648     if (!isCoreProfile)
2649     {
2650       core33back = (OpenGl_GlCore33Back* )(&(*myFuncs));
2651     }
2652   }
2653   else
2654   {
2655     checkWrongVersion (3, 3, aLastFailedProc);
2656   }
2657
2658   // load GL_ARB_draw_indirect (added to OpenGL 4.0 core)
2659   const bool hasDrawIndirect = (IsGlGreaterEqual (4, 0) || CheckExtension ("GL_ARB_draw_indirect"))
2660        && FindProcShort (glDrawArraysIndirect)
2661        && FindProcShort (glDrawElementsIndirect);
2662
2663   // load GL_ARB_gpu_shader_fp64 (added to OpenGL 4.0 core)
2664   const bool hasShaderFP64 = (IsGlGreaterEqual (4, 0) || CheckExtension ("GL_ARB_gpu_shader_fp64"))
2665        && FindProcShort (glUniform1d)
2666        && FindProcShort (glUniform2d)
2667        && FindProcShort (glUniform3d)
2668        && FindProcShort (glUniform4d)
2669        && FindProcShort (glUniform1dv)
2670        && FindProcShort (glUniform2dv)
2671        && FindProcShort (glUniform3dv)
2672        && FindProcShort (glUniform4dv)
2673        && FindProcShort (glUniformMatrix2dv)
2674        && FindProcShort (glUniformMatrix3dv)
2675        && FindProcShort (glUniformMatrix4dv)
2676        && FindProcShort (glUniformMatrix2x3dv)
2677        && FindProcShort (glUniformMatrix2x4dv)
2678        && FindProcShort (glUniformMatrix3x2dv)
2679        && FindProcShort (glUniformMatrix3x4dv)
2680        && FindProcShort (glUniformMatrix4x2dv)
2681        && FindProcShort (glUniformMatrix4x3dv)
2682        && FindProcShort (glGetUniformdv);
2683
2684   // load GL_ARB_shader_subroutine (added to OpenGL 4.0 core)
2685   const bool hasShaderSubroutine = (IsGlGreaterEqual (4, 0) || CheckExtension ("GL_ARB_shader_subroutine"))
2686        && FindProcShort (glGetSubroutineUniformLocation)
2687        && FindProcShort (glGetSubroutineIndex)
2688        && FindProcShort (glGetActiveSubroutineUniformiv)
2689        && FindProcShort (glGetActiveSubroutineUniformName)
2690        && FindProcShort (glGetActiveSubroutineName)
2691        && FindProcShort (glUniformSubroutinesuiv)
2692        && FindProcShort (glGetUniformSubroutineuiv)
2693        && FindProcShort (glGetProgramStageiv);
2694
2695   // load GL_ARB_tessellation_shader (added to OpenGL 4.0 core)
2696   const bool hasTessellationShader = (IsGlGreaterEqual (4, 0) || CheckExtension ("GL_ARB_tessellation_shader"))
2697        && FindProcShort (glPatchParameteri)
2698        && FindProcShort (glPatchParameterfv);
2699
2700   // load GL_ARB_transform_feedback2 (added to OpenGL 4.0 core)
2701   const bool hasTrsfFeedback2 = (IsGlGreaterEqual (4, 0) || CheckExtension ("GL_ARB_transform_feedback2"))
2702        && FindProcShort (glBindTransformFeedback)
2703        && FindProcShort (glDeleteTransformFeedbacks)
2704        && FindProcShort (glGenTransformFeedbacks)
2705        && FindProcShort (glIsTransformFeedback)
2706        && FindProcShort (glPauseTransformFeedback)
2707        && FindProcShort (glResumeTransformFeedback)
2708        && FindProcShort (glDrawTransformFeedback);
2709
2710   // load GL_ARB_transform_feedback3 (added to OpenGL 4.0 core)
2711   const bool hasTrsfFeedback3 = (IsGlGreaterEqual (4, 0) || CheckExtension ("GL_ARB_transform_feedback3"))
2712        && FindProcShort (glDrawTransformFeedbackStream)
2713        && FindProcShort (glBeginQueryIndexed)
2714        && FindProcShort (glEndQueryIndexed)
2715        && FindProcShort (glGetQueryIndexediv);
2716
2717   // load OpenGL 4.0 new functions
2718   has40 = IsGlGreaterEqual (4, 0)
2719       && hasDrawIndirect
2720       && hasShaderFP64
2721       && hasShaderSubroutine
2722       && hasTessellationShader
2723       && hasTrsfFeedback2
2724       && hasTrsfFeedback3
2725       && FindProcShort (glMinSampleShading)
2726       && FindProcShort (glBlendEquationi)
2727       && FindProcShort (glBlendEquationSeparatei)
2728       && FindProcShort (glBlendFunci)
2729       && FindProcShort (glBlendFuncSeparatei);
2730   if (has40)
2731   {
2732     arbTboRGB32 = Standard_True; // in core since OpenGL 4.0
2733   }
2734   else
2735   {
2736     checkWrongVersion (4, 0, aLastFailedProc);
2737   }
2738
2739   // load GL_ARB_ES2_compatibility (added to OpenGL 4.1 core)
2740   const bool hasES2Compatibility = (IsGlGreaterEqual (4, 1) || CheckExtension ("GL_ARB_ES2_compatibility"))
2741        && FindProcShort (glReleaseShaderCompiler)
2742        && FindProcShort (glShaderBinary)
2743        && FindProcShort (glGetShaderPrecisionFormat)
2744        && FindProcShort (glDepthRangef)
2745        && FindProcShort (glClearDepthf);
2746
2747   // load GL_ARB_get_program_binary (added to OpenGL 4.1 core)
2748   const bool hasGetProgramBinary = (IsGlGreaterEqual (4, 1) || CheckExtension ("GL_ARB_get_program_binary"))
2749        && FindProcShort (glGetProgramBinary)
2750        && FindProcShort (glProgramBinary)
2751        && FindProcShort (glProgramParameteri);
2752
2753
2754   // load GL_ARB_separate_shader_objects (added to OpenGL 4.1 core)
2755   const bool hasSeparateShaderObjects = (IsGlGreaterEqual (4, 1) || CheckExtension ("GL_ARB_separate_shader_objects"))
2756        && FindProcShort (glUseProgramStages)
2757        && FindProcShort (glActiveShaderProgram)
2758        && FindProcShort (glCreateShaderProgramv)
2759        && FindProcShort (glBindProgramPipeline)
2760        && FindProcShort (glDeleteProgramPipelines)
2761        && FindProcShort (glGenProgramPipelines)
2762        && FindProcShort (glIsProgramPipeline)
2763        && FindProcShort (glGetProgramPipelineiv)
2764        && FindProcShort (glProgramUniform1i)
2765        && FindProcShort (glProgramUniform1iv)
2766        && FindProcShort (glProgramUniform1f)
2767        && FindProcShort (glProgramUniform1fv)
2768        && FindProcShort (glProgramUniform1d)
2769        && FindProcShort (glProgramUniform1dv)
2770        && FindProcShort (glProgramUniform1ui)
2771        && FindProcShort (glProgramUniform1uiv)
2772        && FindProcShort (glProgramUniform2i)
2773        && FindProcShort (glProgramUniform2iv)
2774        && FindProcShort (glProgramUniform2f)
2775        && FindProcShort (glProgramUniform2fv)
2776        && FindProcShort (glProgramUniform2d)
2777        && FindProcShort (glProgramUniform2dv)
2778        && FindProcShort (glProgramUniform2ui)
2779        && FindProcShort (glProgramUniform2uiv)
2780        && FindProcShort (glProgramUniform3i)
2781        && FindProcShort (glProgramUniform3iv)
2782        && FindProcShort (glProgramUniform3f)
2783        && FindProcShort (glProgramUniform3fv)
2784        && FindProcShort (glProgramUniform3d)
2785        && FindProcShort (glProgramUniform3dv)
2786        && FindProcShort (glProgramUniform3ui)
2787        && FindProcShort (glProgramUniform3uiv)
2788        && FindProcShort (glProgramUniform4i)
2789        && FindProcShort (glProgramUniform4iv)
2790        && FindProcShort (glProgramUniform4f)
2791        && FindProcShort (glProgramUniform4fv)
2792        && FindProcShort (glProgramUniform4d)
2793        && FindProcShort (glProgramUniform4dv)
2794        && FindProcShort (glProgramUniform4ui)
2795        && FindProcShort (glProgramUniform4uiv)
2796        && FindProcShort (glProgramUniformMatrix2fv)
2797        && FindProcShort (glProgramUniformMatrix3fv)
2798        && FindProcShort (glProgramUniformMatrix4fv)
2799        && FindProcShort (glProgramUniformMatrix2dv)
2800        && FindProcShort (glProgramUniformMatrix3dv)
2801        && FindProcShort (glProgramUniformMatrix4dv)
2802        && FindProcShort (glProgramUniformMatrix2x3fv)
2803        && FindProcShort (glProgramUniformMatrix3x2fv)
2804        && FindProcShort (glProgramUniformMatrix2x4fv)
2805        && FindProcShort (glProgramUniformMatrix4x2fv)
2806        && FindProcShort (glProgramUniformMatrix3x4fv)
2807        && FindProcShort (glProgramUniformMatrix4x3fv)
2808        && FindProcShort (glProgramUniformMatrix2x3dv)
2809        && FindProcShort (glProgramUniformMatrix3x2dv)
2810        && FindProcShort (glProgramUniformMatrix2x4dv)
2811        && FindProcShort (glProgramUniformMatrix4x2dv)
2812        && FindProcShort (glProgramUniformMatrix3x4dv)
2813        && FindProcShort (glProgramUniformMatrix4x3dv)
2814        && FindProcShort (glValidateProgramPipeline)
2815        && FindProcShort (glGetProgramPipelineInfoLog);
2816
2817   // load GL_ARB_vertex_attrib_64bit (added to OpenGL 4.1 core)
2818   const bool hasVertAttrib64bit = (IsGlGreaterEqual (4, 1) || CheckExtension ("GL_ARB_vertex_attrib_64bit"))
2819        && FindProcShort (glVertexAttribL1d)
2820        && FindProcShort (glVertexAttribL2d)
2821        && FindProcShort (glVertexAttribL3d)
2822        && FindProcShort (glVertexAttribL4d)
2823        && FindProcShort (glVertexAttribL1dv)
2824        && FindProcShort (glVertexAttribL2dv)
2825        && FindProcShort (glVertexAttribL3dv)
2826        && FindProcShort (glVertexAttribL4dv)
2827        && FindProcShort (glVertexAttribLPointer)
2828        && FindProcShort (glGetVertexAttribLdv);
2829
2830   // load GL_ARB_viewport_array (added to OpenGL 4.1 core)
2831   const bool hasViewportArray = (IsGlGreaterEqual (4, 1) || CheckExtension ("GL_ARB_viewport_array"))
2832        && FindProcShort (glViewportArrayv)
2833        && FindProcShort (glViewportIndexedf)
2834        && FindProcShort (glViewportIndexedfv)
2835        && FindProcShort (glScissorArrayv)
2836        && FindProcShort (glScissorIndexed)
2837        && FindProcShort (glScissorIndexedv)
2838        && FindProcShort (glDepthRangeArrayv)
2839        && FindProcShort (glDepthRangeIndexed)
2840        && FindProcShort (glGetFloati_v)
2841        && FindProcShort (glGetDoublei_v);
2842
2843   has41 = IsGlGreaterEqual (4, 1)
2844        && hasES2Compatibility
2845        && hasGetProgramBinary
2846        && hasSeparateShaderObjects
2847        && hasVertAttrib64bit
2848        && hasViewportArray;
2849   if (has41)
2850   {
2851     core41 = (OpenGl_GlCore41* )(&(*myFuncs));
2852     if (!isCoreProfile)
2853     {
2854       core41back = (OpenGl_GlCore41Back* )(&(*myFuncs));
2855     }
2856   }
2857   else
2858   {
2859     checkWrongVersion (4, 1, aLastFailedProc);
2860   }
2861
2862   // load GL_ARB_base_instance (added to OpenGL 4.2 core)
2863   const bool hasBaseInstance = (IsGlGreaterEqual (4, 2) || CheckExtension ("GL_ARB_base_instance"))
2864        && FindProcShort (glDrawArraysInstancedBaseInstance)
2865        && FindProcShort (glDrawElementsInstancedBaseInstance)
2866        && FindProcShort (glDrawElementsInstancedBaseVertexBaseInstance);
2867
2868   // load GL_ARB_transform_feedback_instanced (added to OpenGL 4.2 core)
2869   const bool hasTrsfFeedbackInstanced = (IsGlGreaterEqual (4, 2) || CheckExtension ("GL_ARB_transform_feedback_instanced"))
2870        && FindProcShort (glDrawTransformFeedbackInstanced)
2871        && FindProcShort (glDrawTransformFeedbackStreamInstanced);
2872
2873   // load GL_ARB_internalformat_query (added to OpenGL 4.2 core)
2874   const bool hasInternalFormatQuery = (IsGlGreaterEqual (4, 2) || CheckExtension ("GL_ARB_internalformat_query"))
2875        && FindProcShort (glGetInternalformativ);
2876
2877   // load GL_ARB_shader_atomic_counters (added to OpenGL 4.2 core)
2878   const bool hasShaderAtomicCounters = (IsGlGreaterEqual (4, 2) || CheckExtension ("GL_ARB_shader_atomic_counters"))
2879        && FindProcShort (glGetActiveAtomicCounterBufferiv);
2880
2881   // load GL_ARB_shader_image_load_store (added to OpenGL 4.2 core)
2882   const bool hasShaderImgLoadStore = (IsGlGreaterEqual (4, 2) || CheckExtension ("GL_ARB_shader_image_load_store"))
2883        && FindProcShort (glBindImageTexture)
2884        && FindProcShort (glMemoryBarrier);
2885
2886   // load GL_ARB_texture_storage (added to OpenGL 4.2 core)
2887   const bool hasTextureStorage = (IsGlGreaterEqual (4, 2) || CheckExtension ("GL_ARB_texture_storage"))
2888        && FindProcShort (glTexStorage1D)
2889        && FindProcShort (glTexStorage2D)
2890        && FindProcShort (glTexStorage3D);
2891
2892   has42 = IsGlGreaterEqual (4, 2)
2893        && hasBaseInstance
2894        && hasTrsfFeedbackInstanced
2895        && hasInternalFormatQuery
2896        && hasShaderAtomicCounters
2897        && hasShaderImgLoadStore
2898        && hasTextureStorage;
2899   if (has42)
2900   {
2901     core42 = (OpenGl_GlCore42* )(&(*myFuncs));
2902     if (!isCoreProfile)
2903     {
2904       core42back = (OpenGl_GlCore42Back* )(&(*myFuncs));
2905     }
2906   }
2907   else
2908   {
2909     checkWrongVersion (4, 2, aLastFailedProc);
2910   }
2911
2912   has43 = IsGlGreaterEqual (4, 3)
2913        && FindProcShort (glClearBufferData)
2914        && FindProcShort (glClearBufferSubData)
2915        && FindProcShort (glDispatchCompute)
2916        && FindProcShort (glDispatchComputeIndirect)
2917        && FindProcShort (glCopyImageSubData)
2918        && FindProcShort (glFramebufferParameteri)
2919        && FindProcShort (glGetFramebufferParameteriv)
2920        && FindProcShort (glGetInternalformati64v)
2921        && FindProcShort (glInvalidateTexSubImage)
2922        && FindProcShort (glInvalidateTexImage)
2923        && FindProcShort (glInvalidateBufferSubData)
2924        && FindProcShort (glInvalidateBufferData)
2925        && FindProcShort (glInvalidateFramebuffer)
2926        && FindProcShort (glInvalidateSubFramebuffer)
2927        && FindProcShort (glMultiDrawArraysIndirect)
2928        && FindProcShort (glMultiDrawElementsIndirect)
2929        && FindProcShort (glGetProgramInterfaceiv)
2930        && FindProcShort (glGetProgramResourceIndex)
2931        && FindProcShort (glGetProgramResourceName)
2932        && FindProcShort (glGetProgramResourceiv)
2933        && FindProcShort (glGetProgramResourceLocation)
2934        && FindProcShort (glGetProgramResourceLocationIndex)
2935        && FindProcShort (glShaderStorageBlockBinding)
2936        && FindProcShort (glTexBufferRange)
2937        && FindProcShort (glTexStorage2DMultisample)
2938        && FindProcShort (glTexStorage3DMultisample)
2939        && FindProcShort (glTextureView)
2940        && FindProcShort (glBindVertexBuffer)
2941        && FindProcShort (glVertexAttribFormat)
2942        && FindProcShort (glVertexAttribIFormat)
2943        && FindProcShort (glVertexAttribLFormat)
2944        && FindProcShort (glVertexAttribBinding)
2945        && FindProcShort (glVertexBindingDivisor)
2946        && FindProcShort (glDebugMessageControl)
2947        && FindProcShort (glDebugMessageInsert)
2948        && FindProcShort (glDebugMessageCallback)
2949        && FindProcShort (glGetDebugMessageLog)
2950        && FindProcShort (glPushDebugGroup)
2951        && FindProcShort (glPopDebugGroup)
2952        && FindProcShort (glObjectLabel)
2953        && FindProcShort (glGetObjectLabel)
2954        && FindProcShort (glObjectPtrLabel)
2955        && FindProcShort (glGetObjectPtrLabel);
2956   if (has43)
2957   {
2958     core43 = (OpenGl_GlCore43* )(&(*myFuncs));
2959     if (!isCoreProfile)
2960     {
2961       core43back = (OpenGl_GlCore43Back* )(&(*myFuncs));
2962     }
2963   }
2964   else
2965   {
2966     checkWrongVersion (4, 3, aLastFailedProc);
2967   }
2968
2969   // load GL_ARB_clear_texture (added to OpenGL 4.4 core)
2970   bool arbTexClear = (IsGlGreaterEqual (4, 4) || CheckExtension ("GL_ARB_clear_texture"))
2971        && FindProcShort (glClearTexImage)
2972        && FindProcShort (glClearTexSubImage);
2973
2974   has44 = IsGlGreaterEqual (4, 4)
2975        && arbTexClear
2976        && FindProcShort (glBufferStorage)
2977        && FindProcShort (glBindBuffersBase)
2978        && FindProcShort (glBindBuffersRange)
2979        && FindProcShort (glBindTextures)
2980        && FindProcShort (glBindSamplers)
2981        && FindProcShort (glBindImageTextures)
2982        && FindProcShort (glBindVertexBuffers);
2983   if (has44)
2984   {
2985     core44 = (OpenGl_GlCore44* )(&(*myFuncs));
2986     if (!isCoreProfile)
2987     {
2988       core44back = (OpenGl_GlCore44Back* )(&(*myFuncs));
2989     }
2990   }
2991   else
2992   {
2993     checkWrongVersion (4, 4, aLastFailedProc);
2994   }
2995
2996   has45 = IsGlGreaterEqual (4, 5)
2997        && FindProcShort (glBindVertexBuffers)
2998        && FindProcShort (glClipControl)
2999        && FindProcShort (glCreateTransformFeedbacks)
3000        && FindProcShort (glTransformFeedbackBufferBase)
3001        && FindProcShort (glTransformFeedbackBufferRange)
3002        && FindProcShort (glGetTransformFeedbackiv)
3003        && FindProcShort (glGetTransformFeedbacki_v)
3004        && FindProcShort (glGetTransformFeedbacki64_v)
3005        && FindProcShort (glCreateBuffers)
3006        && FindProcShort (glNamedBufferStorage)
3007        && FindProcShort (glNamedBufferData)
3008        && FindProcShort (glNamedBufferSubData)
3009        && FindProcShort (glCopyNamedBufferSubData)
3010        && FindProcShort (glClearNamedBufferData)
3011        && FindProcShort (glClearNamedBufferSubData)
3012        && FindProcShort (glMapNamedBuffer)
3013        && FindProcShort (glMapNamedBufferRange)
3014        && FindProcShort (glUnmapNamedBuffer)
3015        && FindProcShort (glFlushMappedNamedBufferRange)
3016        && FindProcShort (glGetNamedBufferParameteriv)
3017        && FindProcShort (glGetNamedBufferParameteri64v)
3018        && FindProcShort (glGetNamedBufferPointerv)
3019        && FindProcShort (glGetNamedBufferSubData)
3020        && FindProcShort (glCreateFramebuffers)
3021        && FindProcShort (glNamedFramebufferRenderbuffer)
3022        && FindProcShort (glNamedFramebufferParameteri)
3023        && FindProcShort (glNamedFramebufferTexture)
3024        && FindProcShort (glNamedFramebufferTextureLayer)
3025        && FindProcShort (glNamedFramebufferDrawBuffer)
3026        && FindProcShort (glNamedFramebufferDrawBuffers)
3027        && FindProcShort (glNamedFramebufferReadBuffer)
3028        && FindProcShort (glInvalidateNamedFramebufferData)
3029        && FindProcShort (glInvalidateNamedFramebufferSubData)
3030        && FindProcShort (glClearNamedFramebufferiv)
3031        && FindProcShort (glClearNamedFramebufferuiv)
3032        && FindProcShort (glClearNamedFramebufferfv)
3033        && FindProcShort (glClearNamedFramebufferfi)
3034        && FindProcShort (glBlitNamedFramebuffer)
3035        && FindProcShort (glCheckNamedFramebufferStatus)
3036        && FindProcShort (glGetNamedFramebufferParameteriv)
3037        && FindProcShort (glGetNamedFramebufferAttachmentParameteriv)
3038        && FindProcShort (glCreateRenderbuffers)
3039        && FindProcShort (glNamedRenderbufferStorage)
3040        && FindProcShort (glNamedRenderbufferStorageMultisample)
3041        && FindProcShort (glGetNamedRenderbufferParameteriv)
3042        && FindProcShort (glCreateTextures)
3043        && FindProcShort (glTextureBuffer)
3044        && FindProcShort (glTextureBufferRange)
3045        && FindProcShort (glTextureStorage1D)
3046        && FindProcShort (glTextureStorage2D)
3047        && FindProcShort (glTextureStorage3D)
3048        && FindProcShort (glTextureStorage2DMultisample)
3049        && FindProcShort (glTextureStorage3DMultisample)
3050        && FindProcShort (glTextureSubImage1D)
3051        && FindProcShort (glTextureSubImage2D)
3052        && FindProcShort (glTextureSubImage3D)
3053        && FindProcShort (glCompressedTextureSubImage1D)
3054        && FindProcShort (glCompressedTextureSubImage2D)
3055        && FindProcShort (glCompressedTextureSubImage3D)
3056        && FindProcShort (glCopyTextureSubImage1D)
3057        && FindProcShort (glCopyTextureSubImage2D)
3058        && FindProcShort (glCopyTextureSubImage3D)
3059        && FindProcShort (glTextureParameterf)
3060        && FindProcShort (glTextureParameterfv)
3061        && FindProcShort (glTextureParameteri)
3062        && FindProcShort (glTextureParameterIiv)
3063        && FindProcShort (glTextureParameterIuiv)
3064        && FindProcShort (glTextureParameteriv)
3065        && FindProcShort (glGenerateTextureMipmap)
3066        && FindProcShort (glBindTextureUnit)
3067        && FindProcShort (glGetTextureImage)
3068        && FindProcShort (glGetCompressedTextureImage)
3069        && FindProcShort (glGetTextureLevelParameterfv)
3070        && FindProcShort (glGetTextureLevelParameteriv)
3071        && FindProcShort (glGetTextureParameterfv)
3072        && FindProcShort (glGetTextureParameterIiv)
3073        && FindProcShort (glGetTextureParameterIuiv)
3074        && FindProcShort (glGetTextureParameteriv)
3075        && FindProcShort (glCreateVertexArrays)
3076        && FindProcShort (glDisableVertexArrayAttrib)
3077        && FindProcShort (glEnableVertexArrayAttrib)
3078        && FindProcShort (glVertexArrayElementBuffer)
3079        && FindProcShort (glVertexArrayVertexBuffer)
3080        && FindProcShort (glVertexArrayVertexBuffers)
3081        && FindProcShort (glVertexArrayAttribBinding)
3082        && FindProcShort (glVertexArrayAttribFormat)
3083        && FindProcShort (glVertexArrayAttribIFormat)
3084        && FindProcShort (glVertexArrayAttribLFormat)
3085        && FindProcShort (glVertexArrayBindingDivisor)
3086        && FindProcShort (glGetVertexArrayiv)
3087        && FindProcShort (glGetVertexArrayIndexediv)
3088        && FindProcShort (glGetVertexArrayIndexed64iv)
3089        && FindProcShort (glCreateSamplers)
3090        && FindProcShort (glCreateProgramPipelines)
3091        && FindProcShort (glCreateQueries)
3092        && FindProcShort (glGetQueryBufferObjecti64v)
3093        && FindProcShort (glGetQueryBufferObjectiv)
3094        && FindProcShort (glGetQueryBufferObjectui64v)
3095        && FindProcShort (glGetQueryBufferObjectuiv)
3096        && FindProcShort (glMemoryBarrierByRegion)
3097        && FindProcShort (glGetTextureSubImage)
3098        && FindProcShort (glGetCompressedTextureSubImage)
3099        && FindProcShort (glGetGraphicsResetStatus)
3100        && FindProcShort (glGetnCompressedTexImage)
3101        && FindProcShort (glGetnTexImage)
3102        && FindProcShort (glGetnUniformdv)
3103        && FindProcShort (glGetnUniformfv)
3104        && FindProcShort (glGetnUniformiv)
3105        && FindProcShort (glGetnUniformuiv)
3106        && FindProcShort (glReadnPixels)
3107        && FindProcShort (glGetnMapdv)
3108        && FindProcShort (glGetnMapfv)
3109        && FindProcShort (glGetnMapiv)
3110        && FindProcShort (glGetnPixelMapfv)
3111        && FindProcShort (glGetnPixelMapuiv)
3112        && FindProcShort (glGetnPixelMapusv)
3113        && FindProcShort (glGetnPolygonStipple)
3114        && FindProcShort (glGetnColorTable)
3115        && FindProcShort (glGetnConvolutionFilter)
3116        && FindProcShort (glGetnSeparableFilter)
3117        && FindProcShort (glGetnHistogram)
3118        && FindProcShort (glGetnMinmax)
3119        && FindProcShort (glTextureBarrier);
3120   if (has45)
3121   {
3122     core45 = (OpenGl_GlCore45* )(&(*myFuncs));
3123     if (!isCoreProfile)
3124     {
3125       core45back = (OpenGl_GlCore45Back* )(&(*myFuncs));
3126     }
3127   }
3128   else
3129   {
3130     checkWrongVersion (4, 5, aLastFailedProc);
3131   }
3132
3133   // initialize debug context extension
3134   if (CheckExtension ("GL_ARB_debug_output"))
3135   {
3136     arbDbg = NULL;
3137     if (has43)
3138     {
3139       arbDbg = (OpenGl_ArbDbg* )(&(*myFuncs));
3140     }
3141     else if (FindProc ("glDebugMessageControlARB",  myFuncs->glDebugMessageControl)
3142           && FindProc ("glDebugMessageInsertARB",   myFuncs->glDebugMessageInsert)
3143           && FindProc ("glDebugMessageCallbackARB", myFuncs->glDebugMessageCallback)
3144           && FindProc ("glGetDebugMessageLogARB",   myFuncs->glGetDebugMessageLog))
3145     {
3146       arbDbg = (OpenGl_ArbDbg* )(&(*myFuncs));
3147     }
3148
3149     if (arbDbg != NULL
3150      && caps->contextDebug)
3151     {
3152       // setup default callback
3153       myIsGlDebugCtx = Standard_True;
3154       arbDbg->glDebugMessageCallback (debugCallbackWrap, this);
3155       if (has43)
3156       {
3157         ::glEnable (GL_DEBUG_OUTPUT);
3158       }
3159       if (caps->contextSyncDebug)
3160       {
3161         ::glEnable (GL_DEBUG_OUTPUT_SYNCHRONOUS);
3162       }
3163     }
3164   }
3165
3166   // initialize FBO extension (ARB)
3167   if (hasFBO)
3168   {
3169     arbFBO     = (OpenGl_ArbFBO*     )(&(*myFuncs));
3170     arbFBOBlit = (OpenGl_ArbFBOBlit* )(&(*myFuncs));
3171     extPDS = Standard_True; // extension for EXT, but part of ARB
3172   }
3173
3174   // initialize GS extension (EXT)
3175   if (CheckExtension ("GL_EXT_geometry_shader4")
3176    && FindProcShort (glProgramParameteriEXT))
3177   {
3178     extGS = (OpenGl_ExtGS* )(&(*myFuncs));
3179   }
3180
3181   // initialize bindless texture extension (ARB)
3182   if (CheckExtension ("GL_ARB_bindless_texture")
3183    && FindProcShort (glGetTextureHandleARB)
3184    && FindProcShort (glGetTextureSamplerHandleARB)
3185    && FindProcShort (glMakeTextureHandleResidentARB)
3186    && FindProcShort (glMakeTextureHandleNonResidentARB)
3187    && FindProcShort (glGetImageHandleARB)
3188    && FindProcShort (glMakeImageHandleResidentARB)
3189    && FindProcShort (glMakeImageHandleNonResidentARB)
3190    && FindProcShort (glUniformHandleui64ARB)
3191    && FindProcShort (glUniformHandleui64vARB)
3192    && FindProcShort (glProgramUniformHandleui64ARB)
3193    && FindProcShort (glProgramUniformHandleui64vARB)
3194    && FindProcShort (glIsTextureHandleResidentARB)
3195    && FindProcShort (glIsImageHandleResidentARB)
3196    && FindProcShort (glVertexAttribL1ui64ARB)
3197    && FindProcShort (glVertexAttribL1ui64vARB)
3198    && FindProcShort (glGetVertexAttribLui64vARB))
3199   {
3200     arbTexBindless = (OpenGl_ArbTexBindless* )(&(*myFuncs));
3201   }
3202
3203   if (has30)
3204   {
3205     // MSAA RenderBuffers have been defined in OpenGL 3.0,
3206     // but MSAA Textures - only in OpenGL 3.2+
3207     if (!has32
3208      && CheckExtension ("GL_ARB_texture_multisample")
3209      && FindProcShort (glTexImage2DMultisample))
3210     {
3211       GLint aNbColorSamples = 0, aNbDepthSamples = 0;
3212       ::glGetIntegerv (GL_MAX_COLOR_TEXTURE_SAMPLES, &aNbColorSamples);
3213       ::glGetIntegerv (GL_MAX_DEPTH_TEXTURE_SAMPLES, &aNbDepthSamples);
3214       myMaxMsaaSamples = Min (aNbColorSamples, aNbDepthSamples);
3215     }
3216     if (!has43
3217      && CheckExtension ("GL_ARB_texture_storage_multisample")
3218      && FindProcShort (glTexStorage2DMultisample))
3219     {
3220       //
3221     }
3222   }
3223
3224   // check whether ray tracing mode is supported
3225   myHasRayTracing = has31
3226                  && arbTboRGB32
3227                  && arbFBOBlit  != NULL;
3228
3229   // check whether textures in ray tracing mode are supported
3230   myHasRayTracingTextures = myHasRayTracing
3231                          && arbTexBindless != NULL;
3232
3233   // check whether adaptive screen sampling in ray tracing mode is supported
3234   myHasRayTracingAdaptiveSampling = myHasRayTracing
3235                                  && has44;
3236   myHasRayTracingAdaptiveSamplingAtomic = myHasRayTracingAdaptiveSampling
3237                                        && CheckExtension ("GL_NV_shader_atomic_float");
3238 #endif
3239
3240   if (arbFBO != NULL
3241    && hasFboSRGB)
3242   {
3243     // Detect if window buffer is considered by OpenGL as sRGB-ready
3244     // (linear RGB color written by shader is automatically converted into sRGB)
3245     // or not (offscreen FBO should be blit into window buffer with gamma correction).
3246     const GLenum aDefWinBuffer =
3247     #if !defined(GL_ES_VERSION_2_0)
3248       GL_BACK_LEFT;
3249     #else
3250       GL_BACK;
3251     #endif
3252     GLint aWinColorEncoding = 0; // GL_LINEAR
3253     arbFBO->glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, aDefWinBuffer, GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, &aWinColorEncoding);
3254     ResetErrors (true);
3255     myIsSRgbWindow = aWinColorEncoding == GL_SRGB;
3256
3257     // On desktop OpenGL, pixel formats are almost always sRGB-ready, even when not requested;
3258     // it is safe behavior on desktop where GL_FRAMEBUFFER_SRGB is disabled by default
3259     // (contrary to OpenGL ES, where it is enabled by default).
3260     // NVIDIA drivers, however, always return GL_LINEAR even for sRGB-ready pixel formats on Windows platform,
3261     // while AMD and Intel report GL_SRGB as expected.
3262     // macOS drivers seems to be also report GL_LINEAR even for [NSColorSpace sRGBColorSpace].
3263   #if !defined(GL_ES_VERSION_2_0)
3264   #ifdef __APPLE__
3265     myIsSRgbWindow = true;
3266   #else
3267     if (!myIsSRgbWindow
3268       && myVendor.Search ("nvidia") != -1)
3269     {
3270       myIsSRgbWindow = true;
3271     }
3272   #endif
3273   #endif
3274     if (!myIsSRgbWindow)
3275     {
3276       Message::SendTrace ("OpenGl_Context, warning: window buffer is not sRGB-ready.\n"
3277                           "Check OpenGL window creation parameters for optimal performance.");
3278     }
3279   }
3280
3281   if (arbTexFloat)
3282   {
3283     mySupportedFormats->Add (Image_Format_GrayF);
3284     mySupportedFormats->Add (Image_Format_AlphaF);
3285     mySupportedFormats->Add (Image_Format_RGBF);
3286     mySupportedFormats->Add (Image_Format_RGBAF);
3287     if (arbTexRG)
3288     {
3289       mySupportedFormats->Add (Image_Format_RGF);
3290     }
3291     if (extBgra)
3292     {
3293     #if !defined(GL_ES_VERSION_2_0)
3294       mySupportedFormats->Add (Image_Format_BGRF);
3295     #endif
3296       mySupportedFormats->Add (Image_Format_BGRAF);
3297     }
3298   }
3299
3300 #ifdef __EMSCRIPTEN__
3301   if (checkEnableWebGlExtension (*this, "GL_WEBGL_compressed_texture_s3tc")) // GL_WEBGL_compressed_texture_s3tc_srgb for sRGB formats
3302   {
3303     mySupportedFormats->Add (Image_CompressedFormat_RGB_S3TC_DXT1);
3304     mySupportedFormats->Add (Image_CompressedFormat_RGBA_S3TC_DXT1);
3305     mySupportedFormats->Add (Image_CompressedFormat_RGBA_S3TC_DXT3);
3306     mySupportedFormats->Add (Image_CompressedFormat_RGBA_S3TC_DXT5);
3307   }
3308 #else
3309   if (CheckExtension ("GL_EXT_texture_compression_s3tc")) // GL_EXT_texture_sRGB for sRGB formats
3310   {
3311     mySupportedFormats->Add (Image_CompressedFormat_RGB_S3TC_DXT1);
3312     mySupportedFormats->Add (Image_CompressedFormat_RGBA_S3TC_DXT1);
3313     mySupportedFormats->Add (Image_CompressedFormat_RGBA_S3TC_DXT3);
3314     mySupportedFormats->Add (Image_CompressedFormat_RGBA_S3TC_DXT5);
3315   }
3316   else
3317   {
3318     if (CheckExtension ("GL_EXT_texture_compression_dxt1"))
3319     {
3320       mySupportedFormats->Add (Image_CompressedFormat_RGB_S3TC_DXT1);
3321       mySupportedFormats->Add (Image_CompressedFormat_RGBA_S3TC_DXT1);
3322     }
3323     if (CheckExtension ("GL_ANGLE_texture_compression_dxt3"))
3324     {
3325       mySupportedFormats->Add (Image_CompressedFormat_RGBA_S3TC_DXT3);
3326     }
3327     if (CheckExtension ("GL_ANGLE_texture_compression_dxt5"))
3328     {
3329       mySupportedFormats->Add (Image_CompressedFormat_RGBA_S3TC_DXT5);
3330     }
3331   }
3332 #endif
3333
3334   // check whether PBR shading model is supported
3335   myHasPBR = arbFBO != NULL
3336           && myMaxTexCombined >= 4
3337           && arbTexRG
3338           && arbTexFloat
3339           && (IsGlGreaterEqual (3, 0)
3340         #if !defined(GL_ES_VERSION_2_0)
3341           || (IsGlGreaterEqual (2, 1) && CheckExtension ("GL_EXT_gpu_shader4"))
3342         #endif
3343              );
3344   if (myHasPBR)
3345   {
3346     myPBREnvLUTTexUnit       = static_cast<Graphic3d_TextureUnit>(myMaxTexCombined + Graphic3d_TextureUnit_PbrEnvironmentLUT);
3347     myPBRDiffIBLMapSHTexUnit = static_cast<Graphic3d_TextureUnit>(myMaxTexCombined + Graphic3d_TextureUnit_PbrIblDiffuseSH);
3348     myPBRSpecIBLMapTexUnit   = static_cast<Graphic3d_TextureUnit>(myMaxTexCombined + Graphic3d_TextureUnit_PbrIblSpecular);
3349   }
3350 }
3351
3352 // =======================================================================
3353 // function : MemoryInfo
3354 // purpose  :
3355 // =======================================================================
3356 Standard_Size OpenGl_Context::AvailableMemory() const
3357 {
3358 #if !defined(GL_ES_VERSION_2_0)
3359   if (atiMem)
3360   {
3361     // this is actually information for VBO pool
3362     // however because pools are mostly shared
3363     // it can be used for total GPU memory estimations
3364     GLint aMemInfo[4];
3365     aMemInfo[0] = 0;
3366     glGetIntegerv (GL_VBO_FREE_MEMORY_ATI, aMemInfo);
3367     // returned value is in KiB, however this maybe changed in future
3368     return Standard_Size(aMemInfo[0]) * 1024;
3369   }
3370   else if (nvxMem)
3371   {
3372     // current available dedicated video memory (in KiB), currently unused GPU memory
3373     GLint aMemInfo = 0;
3374     glGetIntegerv (GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &aMemInfo);
3375     return Standard_Size(aMemInfo) * 1024;
3376   }
3377 #endif
3378   return 0;
3379 }
3380
3381 // =======================================================================
3382 // function : MemoryInfo
3383 // purpose  :
3384 // =======================================================================
3385 TCollection_AsciiString OpenGl_Context::MemoryInfo() const
3386 {
3387   TColStd_IndexedDataMapOfStringString aDict;
3388   MemoryInfo (aDict);
3389
3390   TCollection_AsciiString aText;
3391   for (TColStd_IndexedDataMapOfStringString::Iterator anIter (aDict); anIter.More(); anIter.Next())
3392   {
3393     if (!aText.IsEmpty())
3394     {
3395       aText += "\n";
3396     }
3397     aText += TCollection_AsciiString("  ") + anIter.Key() + ": " + anIter.Value();
3398   }
3399   return aText;
3400 }
3401
3402 // =======================================================================
3403 // function : MemoryInfo
3404 // purpose  :
3405 // =======================================================================
3406 void OpenGl_Context::MemoryInfo (TColStd_IndexedDataMapOfStringString& theDict) const
3407 {
3408 #if defined(GL_ES_VERSION_2_0)
3409   (void )theDict;
3410 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
3411   GLint aGlRendId = 0;
3412   CGLGetParameter (CGLGetCurrentContext(), kCGLCPCurrentRendererID, &aGlRendId);
3413
3414   CGLRendererInfoObj  aRendObj = NULL;
3415   CGOpenGLDisplayMask aDispMask = CGDisplayIDToOpenGLDisplayMask (kCGDirectMainDisplay);
3416   GLint aRendNb = 0;
3417   CGLQueryRendererInfo (aDispMask, &aRendObj, &aRendNb);
3418   for (GLint aRendIter = 0; aRendIter < aRendNb; ++aRendIter)
3419   {
3420     GLint aRendId = 0;
3421     if (CGLDescribeRenderer (aRendObj, aRendIter, kCGLRPRendererID, &aRendId) != kCGLNoError
3422      || aRendId != aGlRendId)
3423     {
3424       continue;
3425     }
3426
3427     //kCGLRPVideoMemoryMegabytes   = 131;
3428     //kCGLRPTextureMemoryMegabytes = 132;
3429     GLint aVMem = 0;
3430   #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1070
3431     if (CGLDescribeRenderer(aRendObj, aRendIter, kCGLRPVideoMemoryMegabytes, &aVMem) == kCGLNoError)
3432     {
3433       addInfo (theDict, "GPU memory",         TCollection_AsciiString() + aVMem + " MiB");
3434     }
3435     if (CGLDescribeRenderer(aRendObj, aRendIter, kCGLRPTextureMemoryMegabytes, &aVMem) == kCGLNoError)
3436     {
3437       addInfo (theDict, "GPU Texture memory", TCollection_AsciiString() + aVMem + " MiB");
3438     }
3439   #else
3440     if (CGLDescribeRenderer(aRendObj, aRendIter, kCGLRPVideoMemory, &aVMem) == kCGLNoError)
3441     {
3442       addInfo (theDict, "GPU memory",         TCollection_AsciiString() + (aVMem / (1024 * 1024)) + " MiB");
3443     }
3444     if (CGLDescribeRenderer(aRendObj, aRendIter, kCGLRPTextureMemory, &aVMem) == kCGLNoError)
3445     {
3446       addInfo (theDict, "GPU Texture memory", TCollection_AsciiString() + (aVMem / (1024 * 1024)) + " MiB");
3447     }
3448   #endif
3449   }
3450 #endif
3451
3452 #if !defined(GL_ES_VERSION_2_0)
3453   if (atiMem)
3454   {
3455     GLint aValues[4];
3456     memset (aValues, 0, sizeof(aValues));
3457     glGetIntegerv (GL_VBO_FREE_MEMORY_ATI, aValues);
3458
3459     // total memory free in the pool
3460     addInfo (theDict, "GPU free memory",    TCollection_AsciiString() + (aValues[0] / 1024) + " MiB");
3461
3462     if (aValues[1] != aValues[0])
3463     {
3464       // largest available free block in the pool
3465       addInfo (theDict, "Largest free block", TCollection_AsciiString() + (aValues[1] / 1024) + " MiB");
3466     }
3467     if (aValues[2] != aValues[0])
3468     {
3469       // total auxiliary memory free
3470       addInfo (theDict, "Free auxiliary memory", TCollection_AsciiString() + (aValues[2] / 1024) + " MiB");
3471     }
3472   }
3473   else if (nvxMem)
3474   {
3475     //current available dedicated video memory (in KiB), currently unused GPU memory
3476     GLint aValue = 0;
3477     glGetIntegerv (GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &aValue);
3478     addInfo (theDict, "GPU free memory", TCollection_AsciiString() + (aValue / 1024) + " MiB");
3479
3480     // dedicated video memory, total size (in KiB) of the GPU memory
3481     GLint aDedicated = 0;
3482     glGetIntegerv (GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX, &aDedicated);
3483     addInfo (theDict, "GPU memory", TCollection_AsciiString() + (aDedicated / 1024) + " MiB");
3484
3485     // total available memory, total size (in KiB) of the memory available for allocations
3486     glGetIntegerv (GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX, &aValue);
3487     if (aValue != aDedicated)
3488     {
3489       // different only for special configurations
3490       addInfo (theDict, "Total memory", TCollection_AsciiString() + (aValue / 1024) + " MiB");
3491     }
3492   }
3493 #if defined(_WIN32)
3494   else if (myFuncs->wglGetGPUInfoAMD != NULL
3495         && myFuncs->wglGetContextGPUIDAMD != NULL)
3496   {
3497     GLuint aTotalMemMiB = 0;
3498     UINT anAmdId = myFuncs->wglGetContextGPUIDAMD ((HGLRC )myGContext);
3499     if (anAmdId != 0)
3500     {
3501       if (myFuncs->wglGetGPUInfoAMD (anAmdId, WGL_GPU_RAM_AMD, GL_UNSIGNED_INT, sizeof(aTotalMemMiB), &aTotalMemMiB) > 0)
3502       {
3503         addInfo (theDict, "GPU memory", TCollection_AsciiString() + (int )aTotalMemMiB + " MiB");
3504       }
3505     }
3506   }
3507 #endif
3508 #endif
3509
3510 #if !defined(GL_ES_VERSION_2_0) && !defined(__APPLE__) && !defined(_WIN32)
3511   // GLX_RENDERER_VENDOR_ID_MESA
3512   if (myFuncs->glXQueryCurrentRendererIntegerMESA != NULL)
3513   {
3514     unsigned int aVMemMiB = 0;
3515     if (myFuncs->glXQueryCurrentRendererIntegerMESA (GLX_RENDERER_VIDEO_MEMORY_MESA, &aVMemMiB) != False)
3516     {
3517       addInfo (theDict, "GPU memory", TCollection_AsciiString() + int(aVMemMiB) + " MiB");
3518     }
3519   }
3520 #endif
3521 }
3522
3523 // =======================================================================
3524 // function : DiagnosticInfo
3525 // purpose  :
3526 // =======================================================================
3527 void OpenGl_Context::DiagnosticInformation (TColStd_IndexedDataMapOfStringString& theDict,
3528                                             Graphic3d_DiagnosticInfo theFlags) const
3529 {
3530   if ((theFlags & Graphic3d_DiagnosticInfo_NativePlatform) != 0)
3531   {
3532   #if defined(HAVE_EGL)
3533     addInfo (theDict, "EGLVersion",    ::eglQueryString ((EGLDisplay )myDisplay, EGL_VERSION));
3534     addInfo (theDict, "EGLVendor",     ::eglQueryString ((EGLDisplay )myDisplay, EGL_VENDOR));
3535     addInfo (theDict, "EGLClientAPIs", ::eglQueryString ((EGLDisplay )myDisplay, EGL_CLIENT_APIS));
3536     if ((theFlags & Graphic3d_DiagnosticInfo_Extensions) != 0)
3537     {
3538       addInfo (theDict, "EGLExtensions", ::eglQueryString ((EGLDisplay )myDisplay, EGL_EXTENSIONS));
3539     }
3540   #elif defined(_WIN32)
3541     if ((theFlags & Graphic3d_DiagnosticInfo_Extensions) != 0
3542      && myFuncs->wglGetExtensionsStringARB != NULL)
3543     {
3544       const char* aWglExts = myFuncs->wglGetExtensionsStringARB ((HDC )myWindowDC);
3545       addInfo (theDict, "WGLExtensions", aWglExts);
3546     }
3547   #elif defined(__APPLE__)
3548     //
3549   #else
3550     Display* aDisplay = (Display*)myDisplay;
3551     const int aScreen = DefaultScreen(aDisplay);
3552     addInfo (theDict, "GLXDirectRendering", ::glXIsDirect (aDisplay, (GLXContext )myGContext) ? "Yes" : "No");
3553     addInfo (theDict, "GLXVendor",  ::glXQueryServerString (aDisplay, aScreen, GLX_VENDOR));
3554     addInfo (theDict, "GLXVersion", ::glXQueryServerString (aDisplay, aScreen, GLX_VERSION));
3555     if ((theFlags & Graphic3d_DiagnosticInfo_Extensions) != 0)
3556     {
3557       const char* aGlxExts = ::glXQueryExtensionsString (aDisplay, aScreen);
3558       addInfo(theDict, "GLXExtensions", aGlxExts);
3559     }
3560
3561     addInfo (theDict, "GLXClientVendor",  ::glXGetClientString (aDisplay, GLX_VENDOR));
3562     addInfo (theDict, "GLXClientVersion", ::glXGetClientString (aDisplay, GLX_VERSION));
3563     if ((theFlags & Graphic3d_DiagnosticInfo_Extensions) != 0)
3564     {
3565       addInfo (theDict, "GLXClientExtensions", ::glXGetClientString (aDisplay, GLX_EXTENSIONS));
3566     }