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