0032308: Configuration - make Xlib dependency optional
[occt.git] / src / OpenGl / OpenGl_GlFunctions.cxx
1 // Copyright (c) 2021 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14 #if defined(_WIN32)
15   #include <windows.h>
16 #endif
17
18 #include <OpenGl_Context.hxx>
19
20 #include <OpenGl_ArbTBO.hxx>
21 #include <OpenGl_ArbIns.hxx>
22 #include <OpenGl_ArbDbg.hxx>
23 #include <OpenGl_ArbFBO.hxx>
24 #include <OpenGl_ExtGS.hxx>
25 #include <OpenGl_ArbSamplerObject.hxx>
26 #include <OpenGl_ArbTexBindless.hxx>
27 #include <OpenGl_GlCore46.hxx>
28
29 #if !defined(HAVE_EGL) && defined(HAVE_XLIB)
30   #include <GL/glx.h>
31 #endif
32
33 // =======================================================================
34 // function : init
35 // purpose  :
36 // =======================================================================
37 void OpenGl_GlFunctions::load (OpenGl_Context& theCtx,
38                                Standard_Boolean theIsCoreProfile)
39 {
40 #if defined(GL_ES_VERSION_2_0)
41   (void )theIsCoreProfile;
42   theCtx.core11ffp = NULL;
43 #else
44   theCtx.core11ffp = !theIsCoreProfile ? (OpenGl_GlCore11* )this : NULL;
45 #endif
46   theCtx.core11fwd  = (OpenGl_GlCore11Fwd* )this;
47   theCtx.core15     = NULL;
48   theCtx.core15fwd  = NULL;
49   theCtx.core20     = NULL;
50   theCtx.core20fwd  = NULL;
51   theCtx.core30     = NULL;
52   theCtx.core32     = NULL;
53   theCtx.core33     = NULL;
54   theCtx.core41     = NULL;
55   theCtx.core42     = NULL;
56   theCtx.core43     = NULL;
57   theCtx.core44     = NULL;
58   theCtx.core45     = NULL;
59   theCtx.core46     = NULL;
60   theCtx.arbTBO     = NULL;
61   theCtx.arbTboRGB32 = false;
62   theCtx.arbClipControl = false;
63   theCtx.arbIns     = NULL;
64   theCtx.arbDbg     = NULL;
65   theCtx.arbFBO     = NULL;
66   theCtx.arbFBOBlit = NULL;
67   theCtx.extGS      = NULL;
68
69   //! Make record shorter to retrieve function pointer using variable with same name
70   const char* aLastFailedProc = NULL;
71   #define FindProcShort(theFunc) theCtx.FindProcVerbose(aLastFailedProc, #theFunc, this->theFunc)
72   #define checkExtensionShort theCtx.CheckExtension
73   #define isGlGreaterEqualShort(theMaj,theMin) theCtx.IsGlGreaterEqual(theMaj,theMin)
74
75 #if defined(GL_ES_VERSION_2_0)
76
77   theCtx.hasTexRGBA8 = isGlGreaterEqualShort (3, 0)
78                     || checkExtensionShort ("GL_OES_rgb8_rgba8");
79   theCtx.hasTexSRGB  = isGlGreaterEqualShort (3, 0);
80   theCtx.hasFboSRGB  = isGlGreaterEqualShort (3, 0);
81   theCtx.hasFboRenderMipmap = isGlGreaterEqualShort (3, 0)
82                            || checkExtensionShort ("GL_OES_fbo_render_mipmap");
83   theCtx.hasSRGBControl = checkExtensionShort ("GL_EXT_sRGB_write_control");
84   theCtx.hasPackRowLength   = isGlGreaterEqualShort (3, 0);
85   theCtx.hasUnpackRowLength = isGlGreaterEqualShort (3, 0); // || checkExtensionShort ("GL_EXT_unpack_subimage");
86   // NPOT textures has limited support within OpenGL ES 2.0
87   // which are relaxed by OpenGL ES 3.0 or some extensions
88   //theCtx.arbNPTW = isGlGreaterEqualShort (3, 0)
89   //           || checkExtensionShort ("GL_OES_texture_npot")
90   //           || checkExtensionShort ("GL_NV_texture_npot_2D_mipmap");
91   theCtx.arbNPTW     = true;
92   theCtx.arbTexRG    = isGlGreaterEqualShort (3, 0)
93                     || checkExtensionShort ("GL_EXT_texture_rg");
94   theCtx.extBgra     = checkExtensionShort ("GL_EXT_texture_format_BGRA8888");
95   theCtx.extAnis = checkExtensionShort ("GL_EXT_texture_filter_anisotropic");
96   theCtx.extPDS  = isGlGreaterEqualShort (3, 0)
97                 || checkExtensionShort ("GL_OES_packed_depth_stencil");
98
99   theCtx.core11fwd = (OpenGl_GlCore11Fwd* )this;
100   if (isGlGreaterEqualShort (2, 0))
101   {
102     // enable compatible functions
103     theCtx.core20    = (OpenGl_GlCore20* )this;
104     theCtx.core20fwd = (OpenGl_GlCore20* )this;
105     theCtx.core15    = (OpenGl_GlCore15* )this;
106     theCtx.core15fwd = (OpenGl_GlCore15* )this;
107     theCtx.arbFBO    = (OpenGl_ArbFBO*   )this;
108   }
109   if (isGlGreaterEqualShort (3, 0)
110    && FindProcShort (glBlitFramebuffer))
111   {
112     theCtx.arbFBOBlit = (OpenGl_ArbFBOBlit* )this;
113   }
114   if (isGlGreaterEqualShort (3, 0)
115    && FindProcShort (glGenSamplers)
116    && FindProcShort (glDeleteSamplers)
117    && FindProcShort (glIsSampler)
118    && FindProcShort (glBindSampler)
119    && FindProcShort (glSamplerParameteri)
120    && FindProcShort (glSamplerParameteriv)
121    && FindProcShort (glSamplerParameterf)
122    && FindProcShort (glSamplerParameterfv)
123    && FindProcShort (glGetSamplerParameteriv)
124    && FindProcShort (glGetSamplerParameterfv))
125    //&& FindProcShort (glSamplerParameterIiv) // only on Desktop or with extensions GL_OES_texture_border_clamp/GL_EXT_texture_border_clamp
126    //&& FindProcShort (glSamplerParameterIuiv)
127    //&& FindProcShort (glGetSamplerParameterIiv)
128    //&& FindProcShort (glGetSamplerParameterIuiv))
129   {
130     theCtx.arbSamplerObject = (OpenGl_ArbSamplerObject* )this;
131   }
132   theCtx.extFragDepth = !isGlGreaterEqualShort(3, 0)
133                       && checkExtensionShort ("GL_EXT_frag_depth");
134   if (isGlGreaterEqualShort (3, 1)
135    && FindProcShort (glTexStorage2DMultisample))
136   {
137     //
138   }
139
140   theCtx.hasUintIndex = isGlGreaterEqualShort (3, 0)
141                      || checkExtensionShort ("GL_OES_element_index_uint");
142   theCtx.hasHighp     = checkExtensionShort ("GL_OES_fragment_precision_high");
143   GLint aRange[2] = {0, 0};
144   GLint aPrec     = 0;
145   ::glGetShaderPrecisionFormat (GL_FRAGMENT_SHADER, GL_HIGH_FLOAT, aRange, &aPrec);
146   if (aPrec != 0)
147   {
148     theCtx.hasHighp = Standard_True;
149   }
150
151   theCtx.arbTexFloat = (isGlGreaterEqualShort (3, 0)
152                      && FindProcShort (glTexImage3D))
153                      || checkExtensionShort ("GL_OES_texture_float");
154   theCtx.hasTexFloatLinear = theCtx.arbTexFloat
155                           && checkExtensionShort ("GL_OES_texture_float_linear");
156
157   const bool hasTexBuffer32  = isGlGreaterEqualShort (3, 2) && FindProcShort (glTexBuffer);
158   const bool hasExtTexBuffer = checkExtensionShort ("GL_EXT_texture_buffer") && theCtx.FindProc ("glTexBufferEXT", this->glTexBuffer);
159   if (hasTexBuffer32 || hasExtTexBuffer)
160   {
161     theCtx.arbTBO = reinterpret_cast<OpenGl_ArbTBO*> (this);
162   }
163
164   bool hasInstanced = isGlGreaterEqualShort (3, 0)
165        && FindProcShort (glVertexAttribDivisor)
166        && FindProcShort (glDrawArraysInstanced)
167        && FindProcShort (glDrawElementsInstanced);
168   if (!hasInstanced)
169   {
170     hasInstanced = checkExtensionShort ("GL_ANGLE_instanced_arrays")
171        && theCtx.FindProc ("glVertexAttribDivisorANGLE",   this->glVertexAttribDivisor)
172        && theCtx.FindProc ("glDrawArraysInstancedANGLE",   this->glDrawArraysInstanced)
173        && theCtx.FindProc ("glDrawElementsInstancedANGLE", this->glDrawElementsInstanced);
174   }
175   if (hasInstanced)
176   {
177     theCtx.arbIns = (OpenGl_ArbIns* )this;
178   }
179
180   const bool hasVAO = isGlGreaterEqualShort (3, 0)
181        && FindProcShort (glBindVertexArray)
182        && FindProcShort (glDeleteVertexArrays)
183        && FindProcShort (glGenVertexArrays)
184        && FindProcShort (glIsVertexArray);
185 #ifndef __EMSCRIPTEN__ // latest Emscripten does not pretend having / simulating mapping buffer functions
186   const bool hasMapBufferRange = isGlGreaterEqualShort (3, 0)
187        && FindProcShort (glMapBufferRange)
188        && FindProcShort (glUnmapBuffer)
189        && FindProcShort (glGetBufferPointerv)
190        && FindProcShort (glFlushMappedBufferRange);
191 #endif
192
193   // load OpenGL ES 3.0 new functions
194   const bool has30es = isGlGreaterEqualShort (3, 0)
195        && hasVAO
196     #ifndef __EMSCRIPTEN__
197        && hasMapBufferRange
198     #endif
199        && hasInstanced
200        && theCtx.arbSamplerObject != NULL
201        && theCtx.arbFBOBlit != NULL
202        && FindProcShort (glReadBuffer)
203        && FindProcShort (glDrawRangeElements)
204        && FindProcShort (glTexImage3D)
205        && FindProcShort (glTexSubImage3D)
206        && FindProcShort (glCopyTexSubImage3D)
207        && FindProcShort (glCompressedTexImage3D)
208        && FindProcShort (glCompressedTexSubImage3D)
209        && FindProcShort (glGenQueries)
210        && FindProcShort (glDeleteQueries)
211        && FindProcShort (glIsQuery)
212        && FindProcShort (glBeginQuery)
213        && FindProcShort (glEndQuery)
214        && FindProcShort (glGetQueryiv)
215        && FindProcShort (glGetQueryObjectuiv)
216        && FindProcShort (glDrawBuffers)
217        && FindProcShort (glUniformMatrix2x3fv)
218        && FindProcShort (glUniformMatrix3x2fv)
219        && FindProcShort (glUniformMatrix2x4fv)
220        && FindProcShort (glUniformMatrix4x2fv)
221        && FindProcShort (glUniformMatrix3x4fv)
222        && FindProcShort (glUniformMatrix4x3fv)
223        && FindProcShort (glRenderbufferStorageMultisample)
224        && FindProcShort (glFramebufferTextureLayer)
225        && FindProcShort (glGetIntegeri_v)
226        && FindProcShort (glBeginTransformFeedback)
227        && FindProcShort (glEndTransformFeedback)
228        && FindProcShort (glBindBufferRange)
229        && FindProcShort (glBindBufferBase)
230        && FindProcShort (glTransformFeedbackVaryings)
231        && FindProcShort (glGetTransformFeedbackVarying)
232        && FindProcShort (glVertexAttribIPointer)
233        && FindProcShort (glGetVertexAttribIiv)
234        && FindProcShort (glGetVertexAttribIuiv)
235        && FindProcShort (glVertexAttribI4i)
236        && FindProcShort (glVertexAttribI4ui)
237        && FindProcShort (glVertexAttribI4iv)
238        && FindProcShort (glVertexAttribI4uiv)
239        && FindProcShort (glGetUniformuiv)
240        && FindProcShort (glGetFragDataLocation)
241        && FindProcShort (glUniform1ui)
242        && FindProcShort (glUniform2ui)
243        && FindProcShort (glUniform3ui)
244        && FindProcShort (glUniform4ui)
245        && FindProcShort (glUniform1uiv)
246        && FindProcShort (glUniform2uiv)
247        && FindProcShort (glUniform3uiv)
248        && FindProcShort (glUniform4uiv)
249        && FindProcShort (glClearBufferiv)
250        && FindProcShort (glClearBufferuiv)
251        && FindProcShort (glClearBufferfv)
252        && FindProcShort (glClearBufferfi)
253        && FindProcShort (glGetStringi)
254        && FindProcShort (glCopyBufferSubData)
255        && FindProcShort (glGetUniformIndices)
256        && FindProcShort (glGetActiveUniformsiv)
257        && FindProcShort (glGetUniformBlockIndex)
258        && FindProcShort (glGetActiveUniformBlockiv)
259        && FindProcShort (glGetActiveUniformBlockName)
260        && FindProcShort (glUniformBlockBinding)
261        && FindProcShort (glFenceSync)
262        && FindProcShort (glIsSync)
263        && FindProcShort (glDeleteSync)
264        && FindProcShort (glClientWaitSync)
265        && FindProcShort (glWaitSync)
266        && FindProcShort (glGetInteger64v)
267        && FindProcShort (glGetSynciv)
268        && FindProcShort (glGetInteger64i_v)
269        && FindProcShort (glGetBufferParameteri64v)
270        && FindProcShort (glBindTransformFeedback)
271        && FindProcShort (glDeleteTransformFeedbacks)
272        && FindProcShort (glGenTransformFeedbacks)
273        && FindProcShort (glIsTransformFeedback)
274        && FindProcShort (glPauseTransformFeedback)
275        && FindProcShort (glResumeTransformFeedback)
276        && FindProcShort (glGetProgramBinary)
277        && FindProcShort (glProgramBinary)
278        && FindProcShort (glProgramParameteri)
279        && FindProcShort (glInvalidateFramebuffer)
280        && FindProcShort (glInvalidateSubFramebuffer)
281        && FindProcShort (glTexStorage2D)
282        && FindProcShort (glTexStorage3D)
283        && FindProcShort (glGetInternalformativ);
284   if (!has30es)
285   {
286     theCtx.checkWrongVersion (3, 0, aLastFailedProc);
287   }
288   else
289   {
290     theCtx.core30 = (OpenGl_GlCore30* )this;
291     theCtx.hasGetBufferData = true;
292   }
293
294   // load OpenGL ES 3.1 new functions
295   const bool has31es = isGlGreaterEqualShort (3, 1)
296        && has30es
297        && FindProcShort (glDispatchCompute)
298        && FindProcShort (glDispatchComputeIndirect)
299        && FindProcShort (glDrawArraysIndirect)
300        && FindProcShort (glDrawElementsIndirect)
301        && FindProcShort (glFramebufferParameteri)
302        && FindProcShort (glGetFramebufferParameteriv)
303        && FindProcShort (glGetProgramInterfaceiv)
304        && FindProcShort (glGetProgramResourceIndex)
305        && FindProcShort (glGetProgramResourceName)
306        && FindProcShort (glGetProgramResourceiv)
307        && FindProcShort (glGetProgramResourceLocation)
308        && FindProcShort (glUseProgramStages)
309        && FindProcShort (glActiveShaderProgram)
310        && FindProcShort (glCreateShaderProgramv)
311        && FindProcShort (glBindProgramPipeline)
312        && FindProcShort (glDeleteProgramPipelines)
313        && FindProcShort (glGenProgramPipelines)
314        && FindProcShort (glIsProgramPipeline)
315        && FindProcShort (glGetProgramPipelineiv)
316        && FindProcShort (glProgramUniform1i)
317        && FindProcShort (glProgramUniform2i)
318        && FindProcShort (glProgramUniform3i)
319        && FindProcShort (glProgramUniform4i)
320        && FindProcShort (glProgramUniform1ui)
321        && FindProcShort (glProgramUniform2ui)
322        && FindProcShort (glProgramUniform3ui)
323        && FindProcShort (glProgramUniform4ui)
324        && FindProcShort (glProgramUniform1f)
325        && FindProcShort (glProgramUniform2f)
326        && FindProcShort (glProgramUniform3f)
327        && FindProcShort (glProgramUniform4f)
328        && FindProcShort (glProgramUniform1iv)
329        && FindProcShort (glProgramUniform2iv)
330        && FindProcShort (glProgramUniform3iv)
331        && FindProcShort (glProgramUniform4iv)
332        && FindProcShort (glProgramUniform1uiv)
333        && FindProcShort (glProgramUniform2uiv)
334        && FindProcShort (glProgramUniform3uiv)
335        && FindProcShort (glProgramUniform4uiv)
336        && FindProcShort (glProgramUniform1fv)
337        && FindProcShort (glProgramUniform2fv)
338        && FindProcShort (glProgramUniform3fv)
339        && FindProcShort (glProgramUniform4fv)
340        && FindProcShort (glProgramUniformMatrix2fv)
341        && FindProcShort (glProgramUniformMatrix3fv)
342        && FindProcShort (glProgramUniformMatrix4fv)
343        && FindProcShort (glProgramUniformMatrix2x3fv)
344        && FindProcShort (glProgramUniformMatrix3x2fv)
345        && FindProcShort (glProgramUniformMatrix2x4fv)
346        && FindProcShort (glProgramUniformMatrix4x2fv)
347        && FindProcShort (glProgramUniformMatrix3x4fv)
348        && FindProcShort (glProgramUniformMatrix4x3fv)
349        && FindProcShort (glValidateProgramPipeline)
350        && FindProcShort (glGetProgramPipelineInfoLog)
351        && FindProcShort (glBindImageTexture)
352        && FindProcShort (glGetBooleani_v)
353        && FindProcShort (glMemoryBarrier)
354        && FindProcShort (glMemoryBarrierByRegion)
355        && FindProcShort (glTexStorage2DMultisample)
356        && FindProcShort (glGetMultisamplefv)
357        && FindProcShort (glSampleMaski)
358        && FindProcShort (glGetTexLevelParameteriv)
359        && FindProcShort (glGetTexLevelParameterfv)
360        && FindProcShort (glBindVertexBuffer)
361        && FindProcShort (glVertexAttribFormat)
362        && FindProcShort (glVertexAttribIFormat)
363        && FindProcShort (glVertexAttribBinding)
364        && FindProcShort (glVertexBindingDivisor);
365   if (!has31es)
366   {
367     theCtx.checkWrongVersion (3, 1, aLastFailedProc);
368   }
369
370   // initialize debug context extension
371   if (isGlGreaterEqualShort (3, 2)
372    || checkExtensionShort ("GL_KHR_debug"))
373   {
374     // this functionality become a part of OpenGL ES 3.2
375     theCtx.arbDbg = NULL;
376     if (isGlGreaterEqualShort (3, 2)
377      && FindProcShort (glDebugMessageControl)
378      && FindProcShort (glDebugMessageInsert)
379      && FindProcShort (glDebugMessageCallback)
380      && FindProcShort (glGetDebugMessageLog))
381     {
382       theCtx.arbDbg = (OpenGl_ArbDbg* )this;
383     }
384     // According to GL_KHR_debug spec, all functions should have KHR suffix.
385     // However, some implementations can export these functions without suffix.
386     else if (!isGlGreaterEqualShort (3, 2)
387      && theCtx.FindProc ("glDebugMessageControlKHR",  this->glDebugMessageControl)
388      && theCtx.FindProc ("glDebugMessageInsertKHR",   this->glDebugMessageInsert)
389      && theCtx.FindProc ("glDebugMessageCallbackKHR", this->glDebugMessageCallback)
390      && theCtx.FindProc ("glGetDebugMessageLogKHR",   this->glGetDebugMessageLog))
391     {
392       theCtx.arbDbg = (OpenGl_ArbDbg* )this;
393     }
394   }
395
396   // load OpenGL ES 3.2 new functions
397   const bool has32es = isGlGreaterEqualShort (3, 2)
398        && has31es
399        && hasTexBuffer32
400        && theCtx.arbDbg != NULL
401        && FindProcShort (glBlendBarrier)
402        && FindProcShort (glCopyImageSubData)
403        && FindProcShort (glPushDebugGroup)
404        && FindProcShort (glPopDebugGroup)
405        && FindProcShort (glObjectLabel)
406        && FindProcShort (glGetObjectLabel)
407        && FindProcShort (glObjectPtrLabel)
408        && FindProcShort (glGetObjectPtrLabel)
409        && FindProcShort (glGetPointerv)
410        && FindProcShort (glEnablei)
411        && FindProcShort (glDisablei)
412        && FindProcShort (glBlendEquationi)
413        && FindProcShort (glBlendEquationSeparatei)
414        && FindProcShort (glBlendFunci)
415        && FindProcShort (glBlendFuncSeparatei)
416        && FindProcShort (glColorMaski)
417        && FindProcShort (glIsEnabledi)
418        && FindProcShort (glDrawElementsBaseVertex)
419        && FindProcShort (glDrawRangeElementsBaseVertex)
420        && FindProcShort (glDrawElementsInstancedBaseVertex)
421        && FindProcShort (glFramebufferTexture)
422        && FindProcShort (glPrimitiveBoundingBox)
423        && FindProcShort (glGetGraphicsResetStatus)
424        && FindProcShort (glReadnPixels)
425        && FindProcShort (glGetnUniformfv)
426        && FindProcShort (glGetnUniformiv)
427        && FindProcShort (glGetnUniformuiv)
428        && FindProcShort (glMinSampleShading)
429        && FindProcShort (glPatchParameteri)
430        && FindProcShort (glTexParameterIiv)
431        && FindProcShort (glTexParameterIuiv)
432        && FindProcShort (glGetTexParameterIiv)
433        && FindProcShort (glGetTexParameterIuiv)
434        && FindProcShort (glSamplerParameterIiv)
435        && FindProcShort (glSamplerParameterIuiv)
436        && FindProcShort (glGetSamplerParameterIiv)
437        && FindProcShort (glGetSamplerParameterIuiv)
438        && FindProcShort (glTexBufferRange)
439        && FindProcShort (glTexStorage3DMultisample);
440   if (!has32es)
441   {
442     theCtx.checkWrongVersion (3, 2, aLastFailedProc);
443   }
444
445   theCtx.arbTboRGB32 = isGlGreaterEqualShort (3, 2); // OpenGL ES 3.2 introduces TBO already supporting RGB32 format
446   theCtx.extDrawBuffers = checkExtensionShort ("GL_EXT_draw_buffers") && theCtx.FindProc ("glDrawBuffersEXT", this->glDrawBuffers);
447   theCtx.arbDrawBuffers = checkExtensionShort ("GL_ARB_draw_buffers") && theCtx.FindProc ("glDrawBuffersARB", this->glDrawBuffers);
448
449   if (isGlGreaterEqualShort (3, 0) && FindProcShort (glDrawBuffers))
450   {
451     theCtx.hasDrawBuffers = OpenGl_FeatureInCore;
452   }
453   else if (theCtx.extDrawBuffers || theCtx.arbDrawBuffers)
454   {
455     theCtx.hasDrawBuffers = OpenGl_FeatureInExtensions;
456   }
457
458   theCtx.hasFloatBuffer     = isGlGreaterEqualShort (3, 2) ? OpenGl_FeatureInCore :
459                               checkExtensionShort ("GL_EXT_color_buffer_float") ? OpenGl_FeatureInExtensions
460                                                                                 : OpenGl_FeatureNotAvailable;
461   theCtx.hasHalfFloatBuffer = isGlGreaterEqualShort (3, 2) ? OpenGl_FeatureInCore :
462                               checkExtensionShort ("GL_EXT_color_buffer_half_float") ? OpenGl_FeatureInExtensions
463                                                                                      : OpenGl_FeatureNotAvailable;
464
465   theCtx.oesSampleVariables = checkExtensionShort ("GL_OES_sample_variables");
466   theCtx.oesStdDerivatives  = checkExtensionShort ("GL_OES_standard_derivatives");
467   theCtx.hasSampleVariables = isGlGreaterEqualShort (3, 2) ? OpenGl_FeatureInCore :
468                               theCtx.oesSampleVariables ? OpenGl_FeatureInExtensions
469                                                         : OpenGl_FeatureNotAvailable;
470   theCtx.hasGlslBitwiseOps = isGlGreaterEqualShort (3, 0)
471                            ? OpenGl_FeatureInCore
472                            : OpenGl_FeatureNotAvailable;
473   // without hasHighp, dFdx/dFdy precision is considered too low for flat shading (visual artifacts)
474   theCtx.hasFlatShading = isGlGreaterEqualShort (3, 0)
475                         ? OpenGl_FeatureInCore
476                          : (theCtx.oesStdDerivatives && theCtx.hasHighp
477                           ? OpenGl_FeatureInExtensions
478                           : OpenGl_FeatureNotAvailable);
479   if (!isGlGreaterEqualShort (3, 1)
480     && theCtx.Vendor().Search("qualcomm") != -1)
481   {
482     // dFdx/dFdy are completely broken on tested Adreno devices with versions below OpenGl ES 3.1
483     theCtx.hasFlatShading = OpenGl_FeatureNotAvailable;
484   }
485
486   theCtx.hasGeometryStage = isGlGreaterEqualShort (3, 2)
487                    ? OpenGl_FeatureInCore
488                    : (checkExtensionShort ("GL_EXT_geometry_shader") && checkExtensionShort ("GL_EXT_shader_io_blocks")
489                      ? OpenGl_FeatureInExtensions
490                      : OpenGl_FeatureNotAvailable);
491 #else
492
493   theCtx.hasTexRGBA8 = true;
494   theCtx.hasTexSRGB       = isGlGreaterEqualShort (2, 1);
495   theCtx.hasFboSRGB       = isGlGreaterEqualShort (2, 1);
496   theCtx.hasSRGBControl   = theCtx.hasFboSRGB;
497   theCtx.hasFboRenderMipmap = true;
498   theCtx.arbDrawBuffers   = checkExtensionShort ("GL_ARB_draw_buffers");
499   theCtx.arbNPTW          = checkExtensionShort ("GL_ARB_texture_non_power_of_two");
500   theCtx.arbTexFloat      = isGlGreaterEqualShort (3, 0)
501                   || checkExtensionShort ("GL_ARB_texture_float");
502   theCtx.hasTexFloatLinear = theCtx.arbTexFloat;
503   theCtx.arbSampleShading = checkExtensionShort ("GL_ARB_sample_shading");
504   theCtx.arbDepthClamp    = isGlGreaterEqualShort (3, 2)
505                   || checkExtensionShort ("GL_ARB_depth_clamp")
506                   || checkExtensionShort ("NV_depth_clamp");
507   theCtx.extBgra          = isGlGreaterEqualShort (1, 2)
508                   || checkExtensionShort ("GL_EXT_bgra");
509   theCtx.extAnis = checkExtensionShort ("GL_EXT_texture_filter_anisotropic");
510   theCtx.extPDS  = checkExtensionShort ("GL_EXT_packed_depth_stencil");
511   theCtx.atiMem  = checkExtensionShort ("GL_ATI_meminfo");
512   theCtx.nvxMem  = checkExtensionShort ("GL_NVX_gpu_memory_info");
513
514   theCtx.hasDrawBuffers = isGlGreaterEqualShort (2, 0) ? OpenGl_FeatureInCore :
515                           theCtx.arbDrawBuffers ? OpenGl_FeatureInExtensions 
516                                                 : OpenGl_FeatureNotAvailable;
517
518   theCtx.hasGlslBitwiseOps = isGlGreaterEqualShort (3, 0)
519                            ? OpenGl_FeatureInCore
520                            : checkExtensionShort ("GL_EXT_gpu_shader4")
521                             ? OpenGl_FeatureInExtensions
522                             : OpenGl_FeatureNotAvailable;
523
524   theCtx.hasFloatBuffer = theCtx.hasHalfFloatBuffer =
525     isGlGreaterEqualShort (3, 0) ? OpenGl_FeatureInCore :
526     checkExtensionShort ("GL_ARB_color_buffer_float") ? OpenGl_FeatureInExtensions
527                                                       : OpenGl_FeatureNotAvailable;
528
529   theCtx.hasGeometryStage = isGlGreaterEqualShort (3, 2)
530                           ? OpenGl_FeatureInCore
531                           : OpenGl_FeatureNotAvailable;
532
533   theCtx.hasSampleVariables = isGlGreaterEqualShort (4, 0) ? OpenGl_FeatureInCore :
534                               theCtx.arbSampleShading ? OpenGl_FeatureInExtensions
535                                                       : OpenGl_FeatureNotAvailable;
536
537   bool has12 = false, has13 = false, has14 = false, has15 = false;
538   bool has20 = false, has21 = false;
539   bool has30 = false, has31 = false, has32 = false, has33 = false;
540   bool has40 = false, has41 = false, has42 = false, has43 = false, has44 = false, has45 = false, has46 = false;
541
542   // retrieve platform-dependent extensions
543 #if defined(HAVE_EGL)
544   //
545 #elif defined(_WIN32)
546   if (FindProcShort (wglGetExtensionsStringARB))
547   {
548     const char* aWglExts = this->wglGetExtensionsStringARB (wglGetCurrentDC());
549     if (checkExtensionShort (aWglExts, "WGL_EXT_swap_control"))
550     {
551       FindProcShort (wglSwapIntervalEXT);
552     }
553     if (checkExtensionShort (aWglExts, "WGL_ARB_pixel_format"))
554     {
555       FindProcShort (wglChoosePixelFormatARB);
556     }
557     if (checkExtensionShort (aWglExts, "WGL_ARB_create_context_profile"))
558     {
559       FindProcShort (wglCreateContextAttribsARB);
560     }
561     if (checkExtensionShort (aWglExts, "WGL_NV_DX_interop"))
562     {
563       FindProcShort (wglDXSetResourceShareHandleNV);
564       FindProcShort (wglDXOpenDeviceNV);
565       FindProcShort (wglDXCloseDeviceNV);
566       FindProcShort (wglDXRegisterObjectNV);
567       FindProcShort (wglDXUnregisterObjectNV);
568       FindProcShort (wglDXObjectAccessNV);
569       FindProcShort (wglDXLockObjectsNV);
570       FindProcShort (wglDXUnlockObjectsNV);
571     }
572     if (checkExtensionShort (aWglExts, "WGL_AMD_gpu_association"))
573     {
574       FindProcShort (wglGetGPUIDsAMD);
575       FindProcShort (wglGetGPUInfoAMD);
576       FindProcShort (wglGetContextGPUIDAMD);
577     }
578   }
579 #elif defined(HAVE_XLIB)
580     const char* aGlxExts = ::glXQueryExtensionsString ((Display* )theCtx.myDisplay, DefaultScreen ((Display* )theCtx.myDisplay));
581     if (checkExtensionShort (aGlxExts, "GLX_EXT_swap_control"))
582     {
583       FindProcShort (glXSwapIntervalEXT);
584     }
585     if (checkExtensionShort (aGlxExts, "GLX_SGI_swap_control"))
586     {
587       FindProcShort (glXSwapIntervalSGI);
588     }
589     if (checkExtensionShort (aGlxExts, "GLX_MESA_query_renderer"))
590     {
591       FindProcShort (glXQueryRendererIntegerMESA);
592       FindProcShort (glXQueryCurrentRendererIntegerMESA);
593       FindProcShort (glXQueryRendererStringMESA);
594       FindProcShort (glXQueryCurrentRendererStringMESA);
595     }
596     //extSwapTear = checkExtensionShort (aGlxExts, "GLX_EXT_swap_control_tear");
597 #endif
598
599   // load OpenGL 1.2 new functions
600   has12 = isGlGreaterEqualShort (1, 2)
601        && FindProcShort (glBlendColor)
602        && FindProcShort (glBlendEquation)
603        && FindProcShort (glDrawRangeElements)
604        && FindProcShort (glTexImage3D)
605        && FindProcShort (glTexSubImage3D)
606        && FindProcShort (glCopyTexSubImage3D);
607   if (!has12)
608   {
609     theCtx.checkWrongVersion (1, 2, aLastFailedProc);
610   }
611
612   // load OpenGL 1.3 new functions
613   has13 = isGlGreaterEqualShort (1, 3)
614        && FindProcShort (glActiveTexture)
615        && FindProcShort (glSampleCoverage)
616        && FindProcShort (glCompressedTexImage3D)
617        && FindProcShort (glCompressedTexImage2D)
618        && FindProcShort (glCompressedTexImage1D)
619        && FindProcShort (glCompressedTexSubImage3D)
620        && FindProcShort (glCompressedTexSubImage2D)
621        && FindProcShort (glCompressedTexSubImage1D)
622        && FindProcShort (glGetCompressedTexImage);
623   if (!has13)
624   {
625     theCtx.checkWrongVersion (1, 3, aLastFailedProc);
626   }
627
628   // load OpenGL 1.4 new functions
629   has14 = isGlGreaterEqualShort (1, 4)
630        && FindProcShort (glBlendFuncSeparate)
631        && FindProcShort (glMultiDrawArrays)
632        && FindProcShort (glMultiDrawElements)
633        && FindProcShort (glPointParameterf)
634        && FindProcShort (glPointParameterfv)
635        && FindProcShort (glPointParameteri)
636        && FindProcShort (glPointParameteriv);
637   if (!has14)
638   {
639     theCtx.checkWrongVersion (1, 4, aLastFailedProc);
640   }
641
642   // load OpenGL 1.5 new functions
643   has15 = isGlGreaterEqualShort (1, 5)
644        && FindProcShort (glGenQueries)
645        && FindProcShort (glDeleteQueries)
646        && FindProcShort (glIsQuery)
647        && FindProcShort (glBeginQuery)
648        && FindProcShort (glEndQuery)
649        && FindProcShort (glGetQueryiv)
650        && FindProcShort (glGetQueryObjectiv)
651        && FindProcShort (glGetQueryObjectuiv)
652        && FindProcShort (glBindBuffer)
653        && FindProcShort (glDeleteBuffers)
654        && FindProcShort (glGenBuffers)
655        && FindProcShort (glIsBuffer)
656        && FindProcShort (glBufferData)
657        && FindProcShort (glBufferSubData)
658        && FindProcShort (glGetBufferSubData)
659        && FindProcShort (glMapBuffer)
660        && FindProcShort (glUnmapBuffer)
661        && FindProcShort (glGetBufferParameteriv)
662        && FindProcShort (glGetBufferPointerv);
663   if (has15)
664   {
665     theCtx.core15    = (OpenGl_GlCore15* )this;
666     theCtx.core15fwd = (OpenGl_GlCore15* )this;
667     theCtx.hasGetBufferData = true;
668   }
669   else
670   {
671     theCtx.checkWrongVersion (1, 5, aLastFailedProc);
672   }
673
674   // load OpenGL 2.0 new functions
675   has20 = isGlGreaterEqualShort (2, 0)
676        && FindProcShort (glBlendEquationSeparate)
677        && FindProcShort (glDrawBuffers)
678        && FindProcShort (glStencilOpSeparate)
679        && FindProcShort (glStencilFuncSeparate)
680        && FindProcShort (glStencilMaskSeparate)
681        && FindProcShort (glAttachShader)
682        && FindProcShort (glBindAttribLocation)
683        && FindProcShort (glCompileShader)
684        && FindProcShort (glCreateProgram)
685        && FindProcShort (glCreateShader)
686        && FindProcShort (glDeleteProgram)
687        && FindProcShort (glDeleteShader)
688        && FindProcShort (glDetachShader)
689        && FindProcShort (glDisableVertexAttribArray)
690        && FindProcShort (glEnableVertexAttribArray)
691        && FindProcShort (glGetActiveAttrib)
692        && FindProcShort (glGetActiveUniform)
693        && FindProcShort (glGetAttachedShaders)
694        && FindProcShort (glGetAttribLocation)
695        && FindProcShort (glGetProgramiv)
696        && FindProcShort (glGetProgramInfoLog)
697        && FindProcShort (glGetShaderiv)
698        && FindProcShort (glGetShaderInfoLog)
699        && FindProcShort (glGetShaderSource)
700        && FindProcShort (glGetUniformLocation)
701        && FindProcShort (glGetUniformfv)
702        && FindProcShort (glGetUniformiv)
703        && FindProcShort (glGetVertexAttribdv)
704        && FindProcShort (glGetVertexAttribfv)
705        && FindProcShort (glGetVertexAttribiv)
706        && FindProcShort (glGetVertexAttribPointerv)
707        && FindProcShort (glIsProgram)
708        && FindProcShort (glIsShader)
709        && FindProcShort (glLinkProgram)
710        && FindProcShort (glShaderSource)
711        && FindProcShort (glUseProgram)
712        && FindProcShort (glUniform1f)
713        && FindProcShort (glUniform2f)
714        && FindProcShort (glUniform3f)
715        && FindProcShort (glUniform4f)
716        && FindProcShort (glUniform1i)
717        && FindProcShort (glUniform2i)
718        && FindProcShort (glUniform3i)
719        && FindProcShort (glUniform4i)
720        && FindProcShort (glUniform1fv)
721        && FindProcShort (glUniform2fv)
722        && FindProcShort (glUniform3fv)
723        && FindProcShort (glUniform4fv)
724        && FindProcShort (glUniform1iv)
725        && FindProcShort (glUniform2iv)
726        && FindProcShort (glUniform3iv)
727        && FindProcShort (glUniform4iv)
728        && FindProcShort (glUniformMatrix2fv)
729        && FindProcShort (glUniformMatrix3fv)
730        && FindProcShort (glUniformMatrix4fv)
731        && FindProcShort (glValidateProgram)
732        && FindProcShort (glVertexAttrib1d)
733        && FindProcShort (glVertexAttrib1dv)
734        && FindProcShort (glVertexAttrib1f)
735        && FindProcShort (glVertexAttrib1fv)
736        && FindProcShort (glVertexAttrib1s)
737        && FindProcShort (glVertexAttrib1sv)
738        && FindProcShort (glVertexAttrib2d)
739        && FindProcShort (glVertexAttrib2dv)
740        && FindProcShort (glVertexAttrib2f)
741        && FindProcShort (glVertexAttrib2fv)
742        && FindProcShort (glVertexAttrib2s)
743        && FindProcShort (glVertexAttrib2sv)
744        && FindProcShort (glVertexAttrib3d)
745        && FindProcShort (glVertexAttrib3dv)
746        && FindProcShort (glVertexAttrib3f)
747        && FindProcShort (glVertexAttrib3fv)
748        && FindProcShort (glVertexAttrib3s)
749        && FindProcShort (glVertexAttrib3sv)
750        && FindProcShort (glVertexAttrib4Nbv)
751        && FindProcShort (glVertexAttrib4Niv)
752        && FindProcShort (glVertexAttrib4Nsv)
753        && FindProcShort (glVertexAttrib4Nub)
754        && FindProcShort (glVertexAttrib4Nubv)
755        && FindProcShort (glVertexAttrib4Nuiv)
756        && FindProcShort (glVertexAttrib4Nusv)
757        && FindProcShort (glVertexAttrib4bv)
758        && FindProcShort (glVertexAttrib4d)
759        && FindProcShort (glVertexAttrib4dv)
760        && FindProcShort (glVertexAttrib4f)
761        && FindProcShort (glVertexAttrib4fv)
762        && FindProcShort (glVertexAttrib4iv)
763        && FindProcShort (glVertexAttrib4s)
764        && FindProcShort (glVertexAttrib4sv)
765        && FindProcShort (glVertexAttrib4ubv)
766        && FindProcShort (glVertexAttrib4uiv)
767        && FindProcShort (glVertexAttrib4usv)
768        && FindProcShort (glVertexAttribPointer);
769   if (has20)
770   {
771     const char* aGlslVer = (const char* )::glGetString (GL_SHADING_LANGUAGE_VERSION);
772     if (aGlslVer == NULL
773     || *aGlslVer == '\0')
774     {
775       // broken context has been detected
776       theCtx.checkWrongVersion (2, 0, "GLSL 1.1");
777     }
778     else
779     {
780       theCtx.core20    = (OpenGl_GlCore20* )this;
781       theCtx.core20fwd = (OpenGl_GlCore20* )this;
782     }
783   }
784   else
785   {
786     theCtx.checkWrongVersion (2, 0, aLastFailedProc);
787   }
788
789   // load OpenGL 2.1 new functions
790   has21 = isGlGreaterEqualShort (2, 1)
791        && FindProcShort (glUniformMatrix2x3fv)
792        && FindProcShort (glUniformMatrix3x2fv)
793        && FindProcShort (glUniformMatrix2x4fv)
794        && FindProcShort (glUniformMatrix4x2fv)
795        && FindProcShort (glUniformMatrix3x4fv)
796        && FindProcShort (glUniformMatrix4x3fv);
797   if (!has21)
798   {
799     theCtx.checkWrongVersion (2, 1, aLastFailedProc);
800   }
801
802   // load GL_ARB_framebuffer_object (added to OpenGL 3.0 core)
803   const bool hasFBO = (isGlGreaterEqualShort (3, 0) || checkExtensionShort ("GL_ARB_framebuffer_object"))
804        && FindProcShort (glIsRenderbuffer)
805        && FindProcShort (glBindRenderbuffer)
806        && FindProcShort (glDeleteRenderbuffers)
807        && FindProcShort (glGenRenderbuffers)
808        && FindProcShort (glRenderbufferStorage)
809        && FindProcShort (glGetRenderbufferParameteriv)
810        && FindProcShort (glIsFramebuffer)
811        && FindProcShort (glBindFramebuffer)
812        && FindProcShort (glDeleteFramebuffers)
813        && FindProcShort (glGenFramebuffers)
814        && FindProcShort (glCheckFramebufferStatus)
815        && FindProcShort (glFramebufferTexture1D)
816        && FindProcShort (glFramebufferTexture2D)
817        && FindProcShort (glFramebufferTexture3D)
818        && FindProcShort (glFramebufferRenderbuffer)
819        && FindProcShort (glGetFramebufferAttachmentParameteriv)
820        && FindProcShort (glGenerateMipmap)
821        && FindProcShort (glBlitFramebuffer)
822        && FindProcShort (glRenderbufferStorageMultisample)
823        && FindProcShort (glFramebufferTextureLayer);
824
825   // load GL_ARB_vertex_array_object (added to OpenGL 3.0 core)
826   const bool hasVAO = (isGlGreaterEqualShort (3, 0) || checkExtensionShort ("GL_ARB_vertex_array_object"))
827        && FindProcShort (glBindVertexArray)
828        && FindProcShort (glDeleteVertexArrays)
829        && FindProcShort (glGenVertexArrays)
830        && FindProcShort (glIsVertexArray);
831
832   // load GL_ARB_map_buffer_range (added to OpenGL 3.0 core)
833   const bool hasMapBufferRange = (isGlGreaterEqualShort (3, 0) || checkExtensionShort ("GL_ARB_map_buffer_range"))
834        && FindProcShort (glMapBufferRange)
835        && FindProcShort (glFlushMappedBufferRange);
836
837   // load OpenGL 3.0 new functions
838   has30 = isGlGreaterEqualShort (3, 0)
839        && hasFBO
840        && hasVAO
841        && hasMapBufferRange
842        && FindProcShort (glColorMaski)
843        && FindProcShort (glGetBooleani_v)
844        && FindProcShort (glGetIntegeri_v)
845        && FindProcShort (glEnablei)
846        && FindProcShort (glDisablei)
847        && FindProcShort (glIsEnabledi)
848        && FindProcShort (glBeginTransformFeedback)
849        && FindProcShort (glEndTransformFeedback)
850        && FindProcShort (glBindBufferRange)
851        && FindProcShort (glBindBufferBase)
852        && FindProcShort (glTransformFeedbackVaryings)
853        && FindProcShort (glGetTransformFeedbackVarying)
854        && FindProcShort (glClampColor)
855        && FindProcShort (glBeginConditionalRender)
856        && FindProcShort (glEndConditionalRender)
857        && FindProcShort (glVertexAttribIPointer)
858        && FindProcShort (glGetVertexAttribIiv)
859        && FindProcShort (glGetVertexAttribIuiv)
860        && FindProcShort (glVertexAttribI1i)
861        && FindProcShort (glVertexAttribI2i)
862        && FindProcShort (glVertexAttribI3i)
863        && FindProcShort (glVertexAttribI4i)
864        && FindProcShort (glVertexAttribI1ui)
865        && FindProcShort (glVertexAttribI2ui)
866        && FindProcShort (glVertexAttribI3ui)
867        && FindProcShort (glVertexAttribI4ui)
868        && FindProcShort (glVertexAttribI1iv)
869        && FindProcShort (glVertexAttribI2iv)
870        && FindProcShort (glVertexAttribI3iv)
871        && FindProcShort (glVertexAttribI4iv)
872        && FindProcShort (glVertexAttribI1uiv)
873        && FindProcShort (glVertexAttribI2uiv)
874        && FindProcShort (glVertexAttribI3uiv)
875        && FindProcShort (glVertexAttribI4uiv)
876        && FindProcShort (glVertexAttribI4bv)
877        && FindProcShort (glVertexAttribI4sv)
878        && FindProcShort (glVertexAttribI4ubv)
879        && FindProcShort (glVertexAttribI4usv)
880        && FindProcShort (glGetUniformuiv)
881        && FindProcShort (glBindFragDataLocation)
882        && FindProcShort (glGetFragDataLocation)
883        && FindProcShort (glUniform1ui)
884        && FindProcShort (glUniform2ui)
885        && FindProcShort (glUniform3ui)
886        && FindProcShort (glUniform4ui)
887        && FindProcShort (glUniform1uiv)
888        && FindProcShort (glUniform2uiv)
889        && FindProcShort (glUniform3uiv)
890        && FindProcShort (glUniform4uiv)
891        && FindProcShort (glTexParameterIiv)
892        && FindProcShort (glTexParameterIuiv)
893        && FindProcShort (glGetTexParameterIiv)
894        && FindProcShort (glGetTexParameterIuiv)
895        && FindProcShort (glClearBufferiv)
896        && FindProcShort (glClearBufferuiv)
897        && FindProcShort (glClearBufferfv)
898        && FindProcShort (glClearBufferfi)
899        && FindProcShort (glGetStringi);
900   if (!has30)
901   {
902     theCtx.checkWrongVersion (3, 0, aLastFailedProc);
903   }
904
905   // load GL_ARB_uniform_buffer_object (added to OpenGL 3.1 core)
906   const bool hasUBO = (isGlGreaterEqualShort (3, 1) || checkExtensionShort ("GL_ARB_uniform_buffer_object"))
907        && FindProcShort (glGetUniformIndices)
908        && FindProcShort (glGetActiveUniformsiv)
909        && FindProcShort (glGetActiveUniformName)
910        && FindProcShort (glGetUniformBlockIndex)
911        && FindProcShort (glGetActiveUniformBlockiv)
912        && FindProcShort (glGetActiveUniformBlockName)
913        && FindProcShort (glUniformBlockBinding);
914
915   // load GL_ARB_copy_buffer (added to OpenGL 3.1 core)
916   const bool hasCopyBufSubData = (isGlGreaterEqualShort (3, 1) || checkExtensionShort ("GL_ARB_copy_buffer"))
917        && FindProcShort (glCopyBufferSubData);
918
919   if (has30)
920   {
921     // NPOT textures are required by OpenGL 2.0 specifications
922     // but doesn't hardware accelerated by some ancient OpenGL 2.1 hardware (GeForce FX, RadeOn 9700 etc.)
923     theCtx.arbNPTW  = true;
924     theCtx.arbTexRG = true;
925
926     theCtx.core30 = (OpenGl_GlCore30* )this;
927   }
928
929   // load OpenGL 3.1 new functions
930   has31 = isGlGreaterEqualShort (3, 1)
931        && hasUBO
932        && hasCopyBufSubData
933        && FindProcShort (glDrawArraysInstanced)
934        && FindProcShort (glDrawElementsInstanced)
935        && FindProcShort (glTexBuffer)
936        && FindProcShort (glPrimitiveRestartIndex);
937   if (has31)
938   {
939     theCtx.arbTBO = (OpenGl_ArbTBO* )this;
940     theCtx.arbIns = (OpenGl_ArbIns* )this;
941   }
942   else
943   {
944     theCtx.checkWrongVersion (3, 1, aLastFailedProc);
945
946     // initialize TBO extension (ARB)
947     if (checkExtensionShort ("GL_ARB_texture_buffer_object")
948      && theCtx.FindProc ("glTexBufferARB", this->glTexBuffer))
949     {
950       theCtx.arbTBO = (OpenGl_ArbTBO* )this;
951     }
952
953     // initialize hardware instancing extension (ARB)
954     if (checkExtensionShort ("GL_ARB_draw_instanced")
955      && theCtx.FindProc ("glDrawArraysInstancedARB",   this->glDrawArraysInstanced)
956      && theCtx.FindProc ("glDrawElementsInstancedARB", this->glDrawElementsInstanced))
957     {
958       theCtx.arbIns = (OpenGl_ArbIns* )this;
959     }
960   }
961
962   theCtx.arbTboRGB32 = checkExtensionShort ("GL_ARB_texture_buffer_object_rgb32");
963
964   // load GL_ARB_draw_elements_base_vertex (added to OpenGL 3.2 core)
965   const bool hasDrawElemsBaseVert = (isGlGreaterEqualShort (3, 2) || checkExtensionShort ("GL_ARB_draw_elements_base_vertex"))
966        && FindProcShort (glDrawElementsBaseVertex)
967        && FindProcShort (glDrawRangeElementsBaseVertex)
968        && FindProcShort (glDrawElementsInstancedBaseVertex)
969        && FindProcShort (glMultiDrawElementsBaseVertex);
970
971   // load GL_ARB_provoking_vertex (added to OpenGL 3.2 core)
972   const bool hasProvokingVert = (isGlGreaterEqualShort (3, 2) || checkExtensionShort ("GL_ARB_provoking_vertex"))
973        && FindProcShort (glProvokingVertex);
974
975   // load GL_ARB_sync (added to OpenGL 3.2 core)
976   const bool hasSync = (isGlGreaterEqualShort (3, 2) || checkExtensionShort ("GL_ARB_sync"))
977        && FindProcShort (glFenceSync)
978        && FindProcShort (glIsSync)
979        && FindProcShort (glDeleteSync)
980        && FindProcShort (glClientWaitSync)
981        && FindProcShort (glWaitSync)
982        && FindProcShort (glGetInteger64v)
983        && FindProcShort (glGetSynciv);
984
985   // load GL_ARB_texture_multisample (added to OpenGL 3.2 core)
986   const bool hasTextureMultisample = (isGlGreaterEqualShort (3, 2) || checkExtensionShort ("GL_ARB_texture_multisample"))
987        && FindProcShort (glTexImage2DMultisample)
988        && FindProcShort (glTexImage3DMultisample)
989        && FindProcShort (glGetMultisamplefv)
990        && FindProcShort (glSampleMaski);
991
992   // load OpenGL 3.2 new functions
993   has32 = isGlGreaterEqualShort (3, 2)
994        && hasDrawElemsBaseVert
995        && hasProvokingVert
996        && hasSync
997        && hasTextureMultisample
998        && FindProcShort (glGetInteger64i_v)
999        && FindProcShort (glGetBufferParameteri64v)
1000        && FindProcShort (glFramebufferTexture);
1001   if (has32)
1002   {
1003     theCtx.core32 = (OpenGl_GlCore32* )this;
1004   }
1005   else
1006   {
1007     theCtx.checkWrongVersion (3, 2, aLastFailedProc);
1008   }
1009
1010   // load GL_ARB_blend_func_extended (added to OpenGL 3.3 core)
1011   const bool hasBlendFuncExtended = (isGlGreaterEqualShort (3, 3) || checkExtensionShort ("GL_ARB_blend_func_extended"))
1012        && FindProcShort (glBindFragDataLocationIndexed)
1013        && FindProcShort (glGetFragDataIndex);
1014
1015   // load GL_ARB_sampler_objects (added to OpenGL 3.3 core)
1016   const bool hasSamplerObjects = (isGlGreaterEqualShort (3, 3) || checkExtensionShort ("GL_ARB_sampler_objects"))
1017        && FindProcShort (glGenSamplers)
1018        && FindProcShort (glDeleteSamplers)
1019        && FindProcShort (glIsSampler)
1020        && FindProcShort (glBindSampler)
1021        && FindProcShort (glSamplerParameteri)
1022        && FindProcShort (glSamplerParameteriv)
1023        && FindProcShort (glSamplerParameterf)
1024        && FindProcShort (glSamplerParameterfv)
1025        && FindProcShort (glSamplerParameterIiv)
1026        && FindProcShort (glSamplerParameterIuiv)
1027        && FindProcShort (glGetSamplerParameteriv)
1028        && FindProcShort (glGetSamplerParameterIiv)
1029        && FindProcShort (glGetSamplerParameterfv)
1030        && FindProcShort (glGetSamplerParameterIuiv);
1031   if (hasSamplerObjects)
1032   {
1033     theCtx.arbSamplerObject = (OpenGl_ArbSamplerObject* )this;
1034   }
1035
1036   // load GL_ARB_timer_query (added to OpenGL 3.3 core)
1037   const bool hasTimerQuery = (isGlGreaterEqualShort (3, 3) || checkExtensionShort ("GL_ARB_timer_query"))
1038        && FindProcShort (glQueryCounter)
1039        && FindProcShort (glGetQueryObjecti64v)
1040        && FindProcShort (glGetQueryObjectui64v);
1041
1042   // load GL_ARB_vertex_type_2_10_10_10_rev (added to OpenGL 3.3 core)
1043   const bool hasVertType21010101rev = (isGlGreaterEqualShort (3, 3) || checkExtensionShort ("GL_ARB_vertex_type_2_10_10_10_rev"))
1044        && FindProcShort (glVertexAttribP1ui)
1045        && FindProcShort (glVertexAttribP1uiv)
1046        && FindProcShort (glVertexAttribP2ui)
1047        && FindProcShort (glVertexAttribP2uiv)
1048        && FindProcShort (glVertexAttribP3ui)
1049        && FindProcShort (glVertexAttribP3uiv)
1050        && FindProcShort (glVertexAttribP4ui)
1051        && FindProcShort (glVertexAttribP4uiv);
1052
1053   // load OpenGL 3.3 extra functions
1054   has33 = isGlGreaterEqualShort (3, 3)
1055        && hasBlendFuncExtended
1056        && hasSamplerObjects
1057        && hasTimerQuery
1058        && hasVertType21010101rev
1059        && FindProcShort (glVertexAttribDivisor);
1060   if (has33)
1061   {
1062     theCtx.core33 = (OpenGl_GlCore33* )this;
1063   }
1064   else
1065   {
1066     theCtx.checkWrongVersion (3, 3, aLastFailedProc);
1067   }
1068
1069   // load GL_ARB_draw_indirect (added to OpenGL 4.0 core)
1070   const bool hasDrawIndirect = (isGlGreaterEqualShort (4, 0) || checkExtensionShort ("GL_ARB_draw_indirect"))
1071        && FindProcShort (glDrawArraysIndirect)
1072        && FindProcShort (glDrawElementsIndirect);
1073
1074   // load GL_ARB_gpu_shader_fp64 (added to OpenGL 4.0 core)
1075   const bool hasShaderFP64 = (isGlGreaterEqualShort (4, 0) || checkExtensionShort ("GL_ARB_gpu_shader_fp64"))
1076        && FindProcShort (glUniform1d)
1077        && FindProcShort (glUniform2d)
1078        && FindProcShort (glUniform3d)
1079        && FindProcShort (glUniform4d)
1080        && FindProcShort (glUniform1dv)
1081        && FindProcShort (glUniform2dv)
1082        && FindProcShort (glUniform3dv)
1083        && FindProcShort (glUniform4dv)
1084        && FindProcShort (glUniformMatrix2dv)
1085        && FindProcShort (glUniformMatrix3dv)
1086        && FindProcShort (glUniformMatrix4dv)
1087        && FindProcShort (glUniformMatrix2x3dv)
1088        && FindProcShort (glUniformMatrix2x4dv)
1089        && FindProcShort (glUniformMatrix3x2dv)
1090        && FindProcShort (glUniformMatrix3x4dv)
1091        && FindProcShort (glUniformMatrix4x2dv)
1092        && FindProcShort (glUniformMatrix4x3dv)
1093        && FindProcShort (glGetUniformdv);
1094
1095   // load GL_ARB_shader_subroutine (added to OpenGL 4.0 core)
1096   const bool hasShaderSubroutine = (isGlGreaterEqualShort (4, 0) || checkExtensionShort ("GL_ARB_shader_subroutine"))
1097        && FindProcShort (glGetSubroutineUniformLocation)
1098        && FindProcShort (glGetSubroutineIndex)
1099        && FindProcShort (glGetActiveSubroutineUniformiv)
1100        && FindProcShort (glGetActiveSubroutineUniformName)
1101        && FindProcShort (glGetActiveSubroutineName)
1102        && FindProcShort (glUniformSubroutinesuiv)
1103        && FindProcShort (glGetUniformSubroutineuiv)
1104        && FindProcShort (glGetProgramStageiv);
1105
1106   // load GL_ARB_tessellation_shader (added to OpenGL 4.0 core)
1107   const bool hasTessellationShader = (isGlGreaterEqualShort (4, 0) || checkExtensionShort ("GL_ARB_tessellation_shader"))
1108        && FindProcShort (glPatchParameteri)
1109        && FindProcShort (glPatchParameterfv);
1110
1111   // load GL_ARB_transform_feedback2 (added to OpenGL 4.0 core)
1112   const bool hasTrsfFeedback2 = (isGlGreaterEqualShort (4, 0) || checkExtensionShort ("GL_ARB_transform_feedback2"))
1113        && FindProcShort (glBindTransformFeedback)
1114        && FindProcShort (glDeleteTransformFeedbacks)
1115        && FindProcShort (glGenTransformFeedbacks)
1116        && FindProcShort (glIsTransformFeedback)
1117        && FindProcShort (glPauseTransformFeedback)
1118        && FindProcShort (glResumeTransformFeedback)
1119        && FindProcShort (glDrawTransformFeedback);
1120
1121   // load GL_ARB_transform_feedback3 (added to OpenGL 4.0 core)
1122   const bool hasTrsfFeedback3 = (isGlGreaterEqualShort (4, 0) || checkExtensionShort ("GL_ARB_transform_feedback3"))
1123        && FindProcShort (glDrawTransformFeedbackStream)
1124        && FindProcShort (glBeginQueryIndexed)
1125        && FindProcShort (glEndQueryIndexed)
1126        && FindProcShort (glGetQueryIndexediv);
1127
1128   // load OpenGL 4.0 new functions
1129   has40 = isGlGreaterEqualShort (4, 0)
1130       && hasDrawIndirect
1131       && hasShaderFP64
1132       && hasShaderSubroutine
1133       && hasTessellationShader
1134       && hasTrsfFeedback2
1135       && hasTrsfFeedback3
1136       && FindProcShort (glMinSampleShading)
1137       && FindProcShort (glBlendEquationi)
1138       && FindProcShort (glBlendEquationSeparatei)
1139       && FindProcShort (glBlendFunci)
1140       && FindProcShort (glBlendFuncSeparatei);
1141   if (has40)
1142   {
1143     theCtx.arbTboRGB32 = true; // in core since OpenGL 4.0
1144   }
1145   else
1146   {
1147     theCtx.checkWrongVersion (4, 0, aLastFailedProc);
1148   }
1149
1150   // load GL_ARB_ES2_compatibility (added to OpenGL 4.1 core)
1151   const bool hasES2Compatibility = (isGlGreaterEqualShort (4, 1) || checkExtensionShort ("GL_ARB_ES2_compatibility"))
1152        && FindProcShort (glReleaseShaderCompiler)
1153        && FindProcShort (glShaderBinary)
1154        && FindProcShort (glGetShaderPrecisionFormat)
1155        && FindProcShort (glDepthRangef)
1156        && FindProcShort (glClearDepthf);
1157
1158   // load GL_ARB_get_program_binary (added to OpenGL 4.1 core)
1159   const bool hasGetProgramBinary = (isGlGreaterEqualShort (4, 1) || checkExtensionShort ("GL_ARB_get_program_binary"))
1160        && FindProcShort (glGetProgramBinary)
1161        && FindProcShort (glProgramBinary)
1162        && FindProcShort (glProgramParameteri);
1163
1164
1165   // load GL_ARB_separate_shader_objects (added to OpenGL 4.1 core)
1166   const bool hasSeparateShaderObjects = (isGlGreaterEqualShort (4, 1) || checkExtensionShort ("GL_ARB_separate_shader_objects"))
1167        && FindProcShort (glUseProgramStages)
1168        && FindProcShort (glActiveShaderProgram)
1169        && FindProcShort (glCreateShaderProgramv)
1170        && FindProcShort (glBindProgramPipeline)
1171        && FindProcShort (glDeleteProgramPipelines)
1172        && FindProcShort (glGenProgramPipelines)
1173        && FindProcShort (glIsProgramPipeline)
1174        && FindProcShort (glGetProgramPipelineiv)
1175        && FindProcShort (glProgramUniform1i)
1176        && FindProcShort (glProgramUniform1iv)
1177        && FindProcShort (glProgramUniform1f)
1178        && FindProcShort (glProgramUniform1fv)
1179        && FindProcShort (glProgramUniform1d)
1180        && FindProcShort (glProgramUniform1dv)
1181        && FindProcShort (glProgramUniform1ui)
1182        && FindProcShort (glProgramUniform1uiv)
1183        && FindProcShort (glProgramUniform2i)
1184        && FindProcShort (glProgramUniform2iv)
1185        && FindProcShort (glProgramUniform2f)
1186        && FindProcShort (glProgramUniform2fv)
1187        && FindProcShort (glProgramUniform2d)
1188        && FindProcShort (glProgramUniform2dv)
1189        && FindProcShort (glProgramUniform2ui)
1190        && FindProcShort (glProgramUniform2uiv)
1191        && FindProcShort (glProgramUniform3i)
1192        && FindProcShort (glProgramUniform3iv)
1193        && FindProcShort (glProgramUniform3f)
1194        && FindProcShort (glProgramUniform3fv)
1195        && FindProcShort (glProgramUniform3d)
1196        && FindProcShort (glProgramUniform3dv)
1197        && FindProcShort (glProgramUniform3ui)
1198        && FindProcShort (glProgramUniform3uiv)
1199        && FindProcShort (glProgramUniform4i)
1200        && FindProcShort (glProgramUniform4iv)
1201        && FindProcShort (glProgramUniform4f)
1202        && FindProcShort (glProgramUniform4fv)
1203        && FindProcShort (glProgramUniform4d)
1204        && FindProcShort (glProgramUniform4dv)
1205        && FindProcShort (glProgramUniform4ui)
1206        && FindProcShort (glProgramUniform4uiv)
1207        && FindProcShort (glProgramUniformMatrix2fv)
1208        && FindProcShort (glProgramUniformMatrix3fv)
1209        && FindProcShort (glProgramUniformMatrix4fv)
1210        && FindProcShort (glProgramUniformMatrix2dv)
1211        && FindProcShort (glProgramUniformMatrix3dv)
1212        && FindProcShort (glProgramUniformMatrix4dv)
1213        && FindProcShort (glProgramUniformMatrix2x3fv)
1214        && FindProcShort (glProgramUniformMatrix3x2fv)
1215        && FindProcShort (glProgramUniformMatrix2x4fv)
1216        && FindProcShort (glProgramUniformMatrix4x2fv)
1217        && FindProcShort (glProgramUniformMatrix3x4fv)
1218        && FindProcShort (glProgramUniformMatrix4x3fv)
1219        && FindProcShort (glProgramUniformMatrix2x3dv)
1220        && FindProcShort (glProgramUniformMatrix3x2dv)
1221        && FindProcShort (glProgramUniformMatrix2x4dv)
1222        && FindProcShort (glProgramUniformMatrix4x2dv)
1223        && FindProcShort (glProgramUniformMatrix3x4dv)
1224        && FindProcShort (glProgramUniformMatrix4x3dv)
1225        && FindProcShort (glValidateProgramPipeline)
1226        && FindProcShort (glGetProgramPipelineInfoLog);
1227
1228   // load GL_ARB_vertex_attrib_64bit (added to OpenGL 4.1 core)
1229   const bool hasVertAttrib64bit = (isGlGreaterEqualShort (4, 1) || checkExtensionShort ("GL_ARB_vertex_attrib_64bit"))
1230        && FindProcShort (glVertexAttribL1d)
1231        && FindProcShort (glVertexAttribL2d)
1232        && FindProcShort (glVertexAttribL3d)
1233        && FindProcShort (glVertexAttribL4d)
1234        && FindProcShort (glVertexAttribL1dv)
1235        && FindProcShort (glVertexAttribL2dv)
1236        && FindProcShort (glVertexAttribL3dv)
1237        && FindProcShort (glVertexAttribL4dv)
1238        && FindProcShort (glVertexAttribLPointer)
1239        && FindProcShort (glGetVertexAttribLdv);
1240
1241   // load GL_ARB_viewport_array (added to OpenGL 4.1 core)
1242   const bool hasViewportArray = (isGlGreaterEqualShort (4, 1) || checkExtensionShort ("GL_ARB_viewport_array"))
1243        && FindProcShort (glViewportArrayv)
1244        && FindProcShort (glViewportIndexedf)
1245        && FindProcShort (glViewportIndexedfv)
1246        && FindProcShort (glScissorArrayv)
1247        && FindProcShort (glScissorIndexed)
1248        && FindProcShort (glScissorIndexedv)
1249        && FindProcShort (glDepthRangeArrayv)
1250        && FindProcShort (glDepthRangeIndexed)
1251        && FindProcShort (glGetFloati_v)
1252        && FindProcShort (glGetDoublei_v);
1253
1254   has41 = isGlGreaterEqualShort (4, 1)
1255        && hasES2Compatibility
1256        && hasGetProgramBinary
1257        && hasSeparateShaderObjects
1258        && hasVertAttrib64bit
1259        && hasViewportArray;
1260   if (has41)
1261   {
1262     theCtx.core41 = (OpenGl_GlCore41* )this;
1263   }
1264   else
1265   {
1266     theCtx.checkWrongVersion (4, 1, aLastFailedProc);
1267   }
1268
1269   // load GL_ARB_base_instance (added to OpenGL 4.2 core)
1270   const bool hasBaseInstance = (isGlGreaterEqualShort (4, 2) || checkExtensionShort ("GL_ARB_base_instance"))
1271        && FindProcShort (glDrawArraysInstancedBaseInstance)
1272        && FindProcShort (glDrawElementsInstancedBaseInstance)
1273        && FindProcShort (glDrawElementsInstancedBaseVertexBaseInstance);
1274
1275   // load GL_ARB_transform_feedback_instanced (added to OpenGL 4.2 core)
1276   const bool hasTrsfFeedbackInstanced = (isGlGreaterEqualShort (4, 2) || checkExtensionShort ("GL_ARB_transform_feedback_instanced"))
1277        && FindProcShort (glDrawTransformFeedbackInstanced)
1278        && FindProcShort (glDrawTransformFeedbackStreamInstanced);
1279
1280   // load GL_ARB_internalformat_query (added to OpenGL 4.2 core)
1281   const bool hasInternalFormatQuery = (isGlGreaterEqualShort (4, 2) || checkExtensionShort ("GL_ARB_internalformat_query"))
1282        && FindProcShort (glGetInternalformativ);
1283
1284   // load GL_ARB_shader_atomic_counters (added to OpenGL 4.2 core)
1285   const bool hasShaderAtomicCounters = (isGlGreaterEqualShort (4, 2) || checkExtensionShort ("GL_ARB_shader_atomic_counters"))
1286        && FindProcShort (glGetActiveAtomicCounterBufferiv);
1287
1288   // load GL_ARB_shader_image_load_store (added to OpenGL 4.2 core)
1289   const bool hasShaderImgLoadStore = (isGlGreaterEqualShort (4, 2) || checkExtensionShort ("GL_ARB_shader_image_load_store"))
1290        && FindProcShort (glBindImageTexture)
1291        && FindProcShort (glMemoryBarrier);
1292
1293   // load GL_ARB_texture_storage (added to OpenGL 4.2 core)
1294   const bool hasTextureStorage = (isGlGreaterEqualShort (4, 2) || checkExtensionShort ("GL_ARB_texture_storage"))
1295        && FindProcShort (glTexStorage1D)
1296        && FindProcShort (glTexStorage2D)
1297        && FindProcShort (glTexStorage3D);
1298
1299   has42 = isGlGreaterEqualShort (4, 2)
1300        && hasBaseInstance
1301        && hasTrsfFeedbackInstanced
1302        && hasInternalFormatQuery
1303        && hasShaderAtomicCounters
1304        && hasShaderImgLoadStore
1305        && hasTextureStorage;
1306   if (has42)
1307   {
1308     theCtx.core42 = (OpenGl_GlCore42* )this;
1309   }
1310   else
1311   {
1312     theCtx.checkWrongVersion (4, 2, aLastFailedProc);
1313   }
1314
1315   has43 = isGlGreaterEqualShort (4, 3)
1316        && FindProcShort (glClearBufferData)
1317        && FindProcShort (glClearBufferSubData)
1318        && FindProcShort (glDispatchCompute)
1319        && FindProcShort (glDispatchComputeIndirect)
1320        && FindProcShort (glCopyImageSubData)
1321        && FindProcShort (glFramebufferParameteri)
1322        && FindProcShort (glGetFramebufferParameteriv)
1323        && FindProcShort (glGetInternalformati64v)
1324        && FindProcShort (glInvalidateTexSubImage)
1325        && FindProcShort (glInvalidateTexImage)
1326        && FindProcShort (glInvalidateBufferSubData)
1327        && FindProcShort (glInvalidateBufferData)
1328        && FindProcShort (glInvalidateFramebuffer)
1329        && FindProcShort (glInvalidateSubFramebuffer)
1330        && FindProcShort (glMultiDrawArraysIndirect)
1331        && FindProcShort (glMultiDrawElementsIndirect)
1332        && FindProcShort (glGetProgramInterfaceiv)
1333        && FindProcShort (glGetProgramResourceIndex)
1334        && FindProcShort (glGetProgramResourceName)
1335        && FindProcShort (glGetProgramResourceiv)
1336        && FindProcShort (glGetProgramResourceLocation)
1337        && FindProcShort (glGetProgramResourceLocationIndex)
1338        && FindProcShort (glShaderStorageBlockBinding)
1339        && FindProcShort (glTexBufferRange)
1340        && FindProcShort (glTexStorage2DMultisample)
1341        && FindProcShort (glTexStorage3DMultisample)
1342        && FindProcShort (glTextureView)
1343        && FindProcShort (glBindVertexBuffer)
1344        && FindProcShort (glVertexAttribFormat)
1345        && FindProcShort (glVertexAttribIFormat)
1346        && FindProcShort (glVertexAttribLFormat)
1347        && FindProcShort (glVertexAttribBinding)
1348        && FindProcShort (glVertexBindingDivisor)
1349        && FindProcShort (glDebugMessageControl)
1350        && FindProcShort (glDebugMessageInsert)
1351        && FindProcShort (glDebugMessageCallback)
1352        && FindProcShort (glGetDebugMessageLog)
1353        && FindProcShort (glPushDebugGroup)
1354        && FindProcShort (glPopDebugGroup)
1355        && FindProcShort (glObjectLabel)
1356        && FindProcShort (glGetObjectLabel)
1357        && FindProcShort (glObjectPtrLabel)
1358        && FindProcShort (glGetObjectPtrLabel);
1359   if (has43)
1360   {
1361     theCtx.core43 = (OpenGl_GlCore43* )this;
1362   }
1363   else
1364   {
1365     theCtx.checkWrongVersion (4, 3, aLastFailedProc);
1366   }
1367
1368   // load GL_ARB_clear_texture (added to OpenGL 4.4 core)
1369   bool arbTexClear = (isGlGreaterEqualShort (4, 4) || checkExtensionShort ("GL_ARB_clear_texture"))
1370        && FindProcShort (glClearTexImage)
1371        && FindProcShort (glClearTexSubImage);
1372
1373   has44 = isGlGreaterEqualShort (4, 4)
1374        && arbTexClear
1375        && FindProcShort (glBufferStorage)
1376        && FindProcShort (glBindBuffersBase)
1377        && FindProcShort (glBindBuffersRange)
1378        && FindProcShort (glBindTextures)
1379        && FindProcShort (glBindSamplers)
1380        && FindProcShort (glBindImageTextures)
1381        && FindProcShort (glBindVertexBuffers);
1382   if (has44)
1383   {
1384     theCtx.core44 = (OpenGl_GlCore44* )this;
1385   }
1386   else
1387   {
1388     theCtx.checkWrongVersion (4, 4, aLastFailedProc);
1389   }
1390
1391   has45 = isGlGreaterEqualShort (4, 5)
1392        && FindProcShort (glBindVertexBuffers)
1393        && FindProcShort (glClipControl)
1394        && FindProcShort (glCreateTransformFeedbacks)
1395        && FindProcShort (glTransformFeedbackBufferBase)
1396        && FindProcShort (glTransformFeedbackBufferRange)
1397        && FindProcShort (glGetTransformFeedbackiv)
1398        && FindProcShort (glGetTransformFeedbacki_v)
1399        && FindProcShort (glGetTransformFeedbacki64_v)
1400        && FindProcShort (glCreateBuffers)
1401        && FindProcShort (glNamedBufferStorage)
1402        && FindProcShort (glNamedBufferData)
1403        && FindProcShort (glNamedBufferSubData)
1404        && FindProcShort (glCopyNamedBufferSubData)
1405        && FindProcShort (glClearNamedBufferData)
1406        && FindProcShort (glClearNamedBufferSubData)
1407        && FindProcShort (glMapNamedBuffer)
1408        && FindProcShort (glMapNamedBufferRange)
1409        && FindProcShort (glUnmapNamedBuffer)
1410        && FindProcShort (glFlushMappedNamedBufferRange)
1411        && FindProcShort (glGetNamedBufferParameteriv)
1412        && FindProcShort (glGetNamedBufferParameteri64v)
1413        && FindProcShort (glGetNamedBufferPointerv)
1414        && FindProcShort (glGetNamedBufferSubData)
1415        && FindProcShort (glCreateFramebuffers)
1416        && FindProcShort (glNamedFramebufferRenderbuffer)
1417        && FindProcShort (glNamedFramebufferParameteri)
1418        && FindProcShort (glNamedFramebufferTexture)
1419        && FindProcShort (glNamedFramebufferTextureLayer)
1420        && FindProcShort (glNamedFramebufferDrawBuffer)
1421        && FindProcShort (glNamedFramebufferDrawBuffers)
1422        && FindProcShort (glNamedFramebufferReadBuffer)
1423        && FindProcShort (glInvalidateNamedFramebufferData)
1424        && FindProcShort (glInvalidateNamedFramebufferSubData)
1425        && FindProcShort (glClearNamedFramebufferiv)
1426        && FindProcShort (glClearNamedFramebufferuiv)
1427        && FindProcShort (glClearNamedFramebufferfv)
1428        && FindProcShort (glClearNamedFramebufferfi)
1429        && FindProcShort (glBlitNamedFramebuffer)
1430        && FindProcShort (glCheckNamedFramebufferStatus)
1431        && FindProcShort (glGetNamedFramebufferParameteriv)
1432        && FindProcShort (glGetNamedFramebufferAttachmentParameteriv)
1433        && FindProcShort (glCreateRenderbuffers)
1434        && FindProcShort (glNamedRenderbufferStorage)
1435        && FindProcShort (glNamedRenderbufferStorageMultisample)
1436        && FindProcShort (glGetNamedRenderbufferParameteriv)
1437        && FindProcShort (glCreateTextures)
1438        && FindProcShort (glTextureBuffer)
1439        && FindProcShort (glTextureBufferRange)
1440        && FindProcShort (glTextureStorage1D)
1441        && FindProcShort (glTextureStorage2D)
1442        && FindProcShort (glTextureStorage3D)
1443        && FindProcShort (glTextureStorage2DMultisample)
1444        && FindProcShort (glTextureStorage3DMultisample)
1445        && FindProcShort (glTextureSubImage1D)
1446        && FindProcShort (glTextureSubImage2D)
1447        && FindProcShort (glTextureSubImage3D)
1448        && FindProcShort (glCompressedTextureSubImage1D)
1449        && FindProcShort (glCompressedTextureSubImage2D)
1450        && FindProcShort (glCompressedTextureSubImage3D)
1451        && FindProcShort (glCopyTextureSubImage1D)
1452        && FindProcShort (glCopyTextureSubImage2D)
1453        && FindProcShort (glCopyTextureSubImage3D)
1454        && FindProcShort (glTextureParameterf)
1455        && FindProcShort (glTextureParameterfv)
1456        && FindProcShort (glTextureParameteri)
1457        && FindProcShort (glTextureParameterIiv)
1458        && FindProcShort (glTextureParameterIuiv)
1459        && FindProcShort (glTextureParameteriv)
1460        && FindProcShort (glGenerateTextureMipmap)
1461        && FindProcShort (glBindTextureUnit)
1462        && FindProcShort (glGetTextureImage)
1463        && FindProcShort (glGetCompressedTextureImage)
1464        && FindProcShort (glGetTextureLevelParameterfv)
1465        && FindProcShort (glGetTextureLevelParameteriv)
1466        && FindProcShort (glGetTextureParameterfv)
1467        && FindProcShort (glGetTextureParameterIiv)
1468        && FindProcShort (glGetTextureParameterIuiv)
1469        && FindProcShort (glGetTextureParameteriv)
1470        && FindProcShort (glCreateVertexArrays)
1471        && FindProcShort (glDisableVertexArrayAttrib)
1472        && FindProcShort (glEnableVertexArrayAttrib)
1473        && FindProcShort (glVertexArrayElementBuffer)
1474        && FindProcShort (glVertexArrayVertexBuffer)
1475        && FindProcShort (glVertexArrayVertexBuffers)
1476        && FindProcShort (glVertexArrayAttribBinding)
1477        && FindProcShort (glVertexArrayAttribFormat)
1478        && FindProcShort (glVertexArrayAttribIFormat)
1479        && FindProcShort (glVertexArrayAttribLFormat)
1480        && FindProcShort (glVertexArrayBindingDivisor)
1481        && FindProcShort (glGetVertexArrayiv)
1482        && FindProcShort (glGetVertexArrayIndexediv)
1483        && FindProcShort (glGetVertexArrayIndexed64iv)
1484        && FindProcShort (glCreateSamplers)
1485        && FindProcShort (glCreateProgramPipelines)
1486        && FindProcShort (glCreateQueries)
1487        && FindProcShort (glGetQueryBufferObjecti64v)
1488        && FindProcShort (glGetQueryBufferObjectiv)
1489        && FindProcShort (glGetQueryBufferObjectui64v)
1490        && FindProcShort (glGetQueryBufferObjectuiv)
1491        && FindProcShort (glMemoryBarrierByRegion)
1492        && FindProcShort (glGetTextureSubImage)
1493        && FindProcShort (glGetCompressedTextureSubImage)
1494        && FindProcShort (glGetGraphicsResetStatus)
1495        && FindProcShort (glGetnCompressedTexImage)
1496        && FindProcShort (glGetnTexImage)
1497        && FindProcShort (glGetnUniformdv)
1498        && FindProcShort (glGetnUniformfv)
1499        && FindProcShort (glGetnUniformiv)
1500        && FindProcShort (glGetnUniformuiv)
1501        && FindProcShort (glReadnPixels)
1502        && FindProcShort (glGetnMapdv)
1503        && FindProcShort (glGetnMapfv)
1504        && FindProcShort (glGetnMapiv)
1505        && FindProcShort (glGetnPixelMapfv)
1506        && FindProcShort (glGetnPixelMapuiv)
1507        && FindProcShort (glGetnPixelMapusv)
1508        && FindProcShort (glGetnPolygonStipple)
1509        && FindProcShort (glGetnColorTable)
1510        && FindProcShort (glGetnConvolutionFilter)
1511        && FindProcShort (glGetnSeparableFilter)
1512        && FindProcShort (glGetnHistogram)
1513        && FindProcShort (glGetnMinmax)
1514        && FindProcShort (glTextureBarrier);
1515   if (has45)
1516   {
1517     theCtx.core45 = (OpenGl_GlCore45* )this;
1518     theCtx.arbClipControl = true;
1519   }
1520   else
1521   {
1522     theCtx.checkWrongVersion (4, 5, aLastFailedProc);
1523   }
1524
1525   has46 = isGlGreaterEqualShort (4, 6)
1526        && FindProcShort (glSpecializeShader)
1527        && FindProcShort (glMultiDrawArraysIndirectCount)
1528        && FindProcShort (glMultiDrawElementsIndirectCount)
1529        && FindProcShort (glPolygonOffsetClamp);
1530   if (has46)
1531   {
1532     theCtx.core46 = (OpenGl_GlCore46* )this;
1533   }
1534   else
1535   {
1536     theCtx.checkWrongVersion (4, 6, aLastFailedProc);
1537   }
1538
1539   // initialize debug context extension
1540   if (checkExtensionShort ("GL_ARB_debug_output"))
1541   {
1542     theCtx.arbDbg = NULL;
1543     if (has43)
1544     {
1545       theCtx.arbDbg = (OpenGl_ArbDbg* )this;
1546     }
1547     else if (theCtx.FindProc ("glDebugMessageControlARB",  this->glDebugMessageControl)
1548           && theCtx.FindProc ("glDebugMessageInsertARB",   this->glDebugMessageInsert)
1549           && theCtx.FindProc ("glDebugMessageCallbackARB", this->glDebugMessageCallback)
1550           && theCtx.FindProc ("glGetDebugMessageLogARB",   this->glGetDebugMessageLog))
1551     {
1552       theCtx.arbDbg = (OpenGl_ArbDbg* )this;
1553     }
1554   }
1555
1556   // initialize FBO extension (ARB)
1557   if (hasFBO)
1558   {
1559     theCtx.arbFBO     = (OpenGl_ArbFBO*     )this;
1560     theCtx.arbFBOBlit = (OpenGl_ArbFBOBlit* )this;
1561     theCtx.extPDS = Standard_True; // extension for EXT, but part of ARB
1562   }
1563
1564   // initialize GS extension (EXT)
1565   if (checkExtensionShort ("GL_EXT_geometry_shader4")
1566    && FindProcShort (glProgramParameteriEXT))
1567   {
1568     theCtx.extGS = (OpenGl_ExtGS* )this;
1569   }
1570
1571   // initialize bindless texture extension (ARB)
1572   if (checkExtensionShort ("GL_ARB_bindless_texture")
1573    && FindProcShort (glGetTextureHandleARB)
1574    && FindProcShort (glGetTextureSamplerHandleARB)
1575    && FindProcShort (glMakeTextureHandleResidentARB)
1576    && FindProcShort (glMakeTextureHandleNonResidentARB)
1577    && FindProcShort (glGetImageHandleARB)
1578    && FindProcShort (glMakeImageHandleResidentARB)
1579    && FindProcShort (glMakeImageHandleNonResidentARB)
1580    && FindProcShort (glUniformHandleui64ARB)
1581    && FindProcShort (glUniformHandleui64vARB)
1582    && FindProcShort (glProgramUniformHandleui64ARB)
1583    && FindProcShort (glProgramUniformHandleui64vARB)
1584    && FindProcShort (glIsTextureHandleResidentARB)
1585    && FindProcShort (glIsImageHandleResidentARB)
1586    && FindProcShort (glVertexAttribL1ui64ARB)
1587    && FindProcShort (glVertexAttribL1ui64vARB)
1588    && FindProcShort (glGetVertexAttribLui64vARB))
1589   {
1590     theCtx.arbTexBindless = (OpenGl_ArbTexBindless* )this;
1591   }
1592
1593   if (!has45
1594     && checkExtensionShort ("GL_ARB_clip_control")
1595     && FindProcShort (glClipControl))
1596   {
1597     theCtx.arbClipControl = true;
1598   }
1599
1600   if (has30)
1601   {
1602     if (!has32
1603      && checkExtensionShort ("GL_ARB_texture_multisample")
1604      && FindProcShort (glTexImage2DMultisample))
1605     {
1606       //
1607     }
1608     if (!has43
1609      && checkExtensionShort ("GL_ARB_texture_storage_multisample")
1610      && FindProcShort (glTexStorage2DMultisample))
1611     {
1612       //
1613     }
1614   }
1615 #endif
1616 }