1 // Copyright (C) 2002-2012 Nikolaus Gebhardt
\r
2 // This file is part of the "Irrlicht Engine".
\r
3 // For conditions of distribution and use, see copyright notice in irrlicht.h
\r
5 #include "COpenGLExtensionHandler.h"
\r
7 #ifdef _IRR_COMPILE_WITH_OPENGL_
\r
9 #include "irrString.h"
\r
10 #include "SMaterial.h"
\r
11 #include "fast_atof.h"
\r
18 bool COpenGLExtensionHandler::needsDSAFramebufferHack = true;
\r
20 COpenGLExtensionHandler::COpenGLExtensionHandler() :
\r
21 StencilBuffer(false), TextureCompressionExtension(false), MaxLights(1),
\r
22 MaxAnisotropy(1), MaxUserClipPlanes(0), MaxAuxBuffers(0), MaxIndices(65535),
\r
23 MaxTextureSize(1), MaxGeometryVerticesOut(0),
\r
24 MaxTextureLODBias(0.f), Version(0), ShaderLanguageVersion(0),
\r
25 OcclusionQuerySupport(false)
\r
26 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
\r
27 ,pGlActiveTexture(0)
\r
28 ,pGlActiveTextureARB(0), pGlClientActiveTextureARB(0),
\r
29 pGlGenProgramsARB(0), pGlGenProgramsNV(0),
\r
30 pGlBindProgramARB(0), pGlBindProgramNV(0),
\r
31 pGlDeleteProgramsARB(0), pGlDeleteProgramsNV(0),
\r
32 pGlProgramStringARB(0), pGlLoadProgramNV(0),
\r
33 pGlProgramLocalParameter4fvARB(0),
\r
34 pGlCreateShaderObjectARB(0), pGlShaderSourceARB(0),
\r
35 pGlCompileShaderARB(0), pGlCreateProgramObjectARB(0), pGlAttachObjectARB(0),
\r
36 pGlLinkProgramARB(0), pGlUseProgramObjectARB(0), pGlDeleteObjectARB(0),
\r
37 pGlCreateProgram(0), pGlUseProgram(0),
\r
38 pGlDeleteProgram(0), pGlDeleteShader(0),
\r
39 pGlGetAttachedObjectsARB(0), pGlGetAttachedShaders(0),
\r
40 pGlCreateShader(0), pGlShaderSource(0), pGlCompileShader(0),
\r
41 pGlAttachShader(0), pGlLinkProgram(0),
\r
42 pGlGetInfoLogARB(0), pGlGetShaderInfoLog(0), pGlGetProgramInfoLog(0),
\r
43 pGlGetObjectParameterivARB(0), pGlGetShaderiv(0), pGlGetProgramiv(0),
\r
44 pGlGetUniformLocationARB(0), pGlGetUniformLocation(0),
\r
45 pGlUniform1fvARB(0), pGlUniform2fvARB(0), pGlUniform3fvARB(0), pGlUniform4fvARB(0),
\r
46 pGlUniform1ivARB(0), pGlUniform2ivARB(0), pGlUniform3ivARB(0), pGlUniform4ivARB(0),
\r
47 pGlUniformMatrix2fvARB(0), pGlUniformMatrix3fvARB(0), pGlUniformMatrix4fvARB(0),
\r
48 pGlGetActiveUniformARB(0), pGlGetActiveUniform(0),
\r
49 pGlPointParameterfARB(0), pGlPointParameterfvARB(0),
\r
50 pGlStencilFuncSeparate(0), pGlStencilOpSeparate(0),
\r
51 pGlStencilFuncSeparateATI(0), pGlStencilOpSeparateATI(0),
\r
52 pGlCompressedTexImage2D(0), pGlCompressedTexSubImage2D(0),
\r
53 // ARB framebuffer object
\r
54 pGlBindFramebuffer(0), pGlDeleteFramebuffers(0), pGlGenFramebuffers(0),
\r
55 pGlCheckFramebufferStatus(0), pGlFramebufferTexture2D(0),
\r
56 pGlBindRenderbuffer(0), pGlDeleteRenderbuffers(0), pGlGenRenderbuffers(0),
\r
57 pGlRenderbufferStorage(0), pGlFramebufferRenderbuffer(0), pGlGenerateMipmap(0),
\r
58 // EXT framebuffer object
\r
59 pGlBindFramebufferEXT(0), pGlDeleteFramebuffersEXT(0), pGlGenFramebuffersEXT(0),
\r
60 pGlCheckFramebufferStatusEXT(0), pGlFramebufferTexture2DEXT(0),
\r
61 pGlBindRenderbufferEXT(0), pGlDeleteRenderbuffersEXT(0), pGlGenRenderbuffersEXT(0),
\r
62 pGlRenderbufferStorageEXT(0), pGlFramebufferRenderbufferEXT(0), pGlGenerateMipmapEXT(0),
\r
63 pGlActiveStencilFaceEXT(0),
\r
65 pGlDrawBuffersARB(0), pGlDrawBuffersATI(0),
\r
66 pGlGenBuffersARB(0), pGlBindBufferARB(0), pGlBufferDataARB(0), pGlDeleteBuffersARB(0),
\r
67 pGlBufferSubDataARB(0), pGlGetBufferSubDataARB(0), pGlMapBufferARB(0), pGlUnmapBufferARB(0),
\r
68 pGlIsBufferARB(0), pGlGetBufferParameterivARB(0), pGlGetBufferPointervARB(0),
\r
69 pGlProvokingVertexARB(0), pGlProvokingVertexEXT(0),
\r
70 pGlProgramParameteriARB(0), pGlProgramParameteriEXT(0),
\r
71 pGlGenQueriesARB(0), pGlDeleteQueriesARB(0), pGlIsQueryARB(0),
\r
72 pGlBeginQueryARB(0), pGlEndQueryARB(0), pGlGetQueryivARB(0),
\r
73 pGlGetQueryObjectivARB(0), pGlGetQueryObjectuivARB(0),
\r
74 pGlGenOcclusionQueriesNV(0), pGlDeleteOcclusionQueriesNV(0),
\r
75 pGlIsOcclusionQueryNV(0), pGlBeginOcclusionQueryNV(0),
\r
76 pGlEndOcclusionQueryNV(0), pGlGetOcclusionQueryivNV(0),
\r
77 pGlGetOcclusionQueryuivNV(0),
\r
79 pGlBlendFuncSeparateEXT(0), pGlBlendFuncSeparate(0),
\r
80 pGlBlendEquationEXT(0), pGlBlendEquation(0), pGlBlendEquationSeparateEXT(0), pGlBlendEquationSeparate(0),
\r
82 pGlEnableIndexedEXT(0), pGlDisableIndexedEXT(0),
\r
83 pGlColorMaskIndexedEXT(0),
\r
84 pGlBlendFuncIndexedAMD(0), pGlBlendFunciARB(0), pGlBlendFuncSeparateIndexedAMD(0), pGlBlendFuncSeparateiARB(0),
\r
85 pGlBlendEquationIndexedAMD(0), pGlBlendEquationiARB(0), pGlBlendEquationSeparateIndexedAMD(0), pGlBlendEquationSeparateiARB(0),
\r
87 pGlTextureStorage2D(0), pGlTextureStorage3D(0), pGlTextureSubImage2D(0), pGlNamedFramebufferTexture(0),
\r
88 pGlTextureParameteri(0), pGlCreateTextures(0), pGlCreateFramebuffers(0), pGlBindTextures(0), pGlGenerateTextureMipmap(0),
\r
89 // DSA with EXT or functions to simulate it
\r
90 pGlTextureSubImage2DEXT(0), pGlTextureStorage2DEXT(0), pGlTexStorage2D(0), pGlTextureStorage3DEXT(0),
\r
91 pGlTexStorage3D(0), pGlNamedFramebufferTextureEXT(0), pGlFramebufferTexture(0), pGlGenerateTextureMipmapEXT(0)
\r
92 #if defined(GLX_SGI_swap_control)
\r
93 ,pGlxSwapIntervalSGI(0)
\r
95 #if defined(GLX_EXT_swap_control)
\r
96 ,pGlxSwapIntervalEXT(0)
\r
98 #if defined(WGL_EXT_swap_control)
\r
99 ,pWglSwapIntervalEXT(0)
\r
101 #if defined(GLX_MESA_swap_control)
\r
102 ,pGlxSwapIntervalMESA(0)
\r
104 #endif // _IRR_OPENGL_USE_EXTPOINTER_
\r
106 for (u32 i=0; i<IRR_OpenGL_Feature_Count; ++i)
\r
107 FeatureAvailable[i]=false;
\r
108 DimAliasedLine[0]=1.f;
\r
109 DimAliasedLine[1]=1.f;
\r
110 DimAliasedPoint[0]=1.f;
\r
111 DimAliasedPoint[1]=1.f;
\r
112 DimSmoothedLine[0]=1.f;
\r
113 DimSmoothedLine[1]=1.f;
\r
114 DimSmoothedPoint[0]=1.f;
\r
115 DimSmoothedPoint[1]=1.f;
\r
119 void COpenGLExtensionHandler::dump(ELOG_LEVEL logLevel) const
\r
121 for (u32 i=0; i<IRR_OpenGL_Feature_Count; ++i)
\r
122 os::Printer::log(OpenGLFeatureStrings[i], FeatureAvailable[i]?" true":" false", logLevel);
\r
126 void COpenGLExtensionHandler::dumpFramebufferFormats() const
\r
128 #ifdef _IRR_WINDOWS_API_
\r
129 HDC hdc=wglGetCurrentDC();
\r
130 core::stringc wglExtensions;
\r
131 #ifdef WGL_ARB_extensions_string
\r
132 PFNWGLGETEXTENSIONSSTRINGARBPROC irrGetExtensionsString = (PFNWGLGETEXTENSIONSSTRINGARBPROC)wglGetProcAddress("wglGetExtensionsStringARB");
\r
133 if (irrGetExtensionsString)
\r
134 wglExtensions = irrGetExtensionsString(hdc);
\r
135 #elif defined(WGL_EXT_extensions_string)
\r
136 PFNWGLGETEXTENSIONSSTRINGEXTPROC irrGetExtensionsString = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)wglGetProcAddress("wglGetExtensionsStringEXT");
\r
137 if (irrGetExtensionsString)
\r
138 wglExtensions = irrGetExtensionsString(hdc);
\r
140 const bool pixel_format_supported = (wglExtensions.find("WGL_ARB_pixel_format") != -1);
\r
141 const bool multi_sample_supported = ((wglExtensions.find("WGL_ARB_multisample") != -1) ||
\r
142 (wglExtensions.find("WGL_EXT_multisample") != -1) || (wglExtensions.find("WGL_3DFX_multisample") != -1) );
\r
144 os::Printer::log("WGL_extensions", wglExtensions);
\r
147 #ifdef WGL_ARB_pixel_format
\r
148 PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormat_ARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB");
\r
149 if (pixel_format_supported && wglChoosePixelFormat_ARB)
\r
151 // This value determines the number of samples used for antialiasing
\r
152 // My experience is that 8 does not show a big
\r
153 // improvement over 4, but 4 shows a big improvement
\r
156 PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribiv_ARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)wglGetProcAddress("wglGetPixelFormatAttribivARB");
\r
157 if (wglGetPixelFormatAttribiv_ARB)
\r
161 WGL_NUMBER_PIXEL_FORMATS_ARB,
\r
162 WGL_DRAW_TO_BITMAP_ARB,
\r
163 WGL_ACCELERATION_ARB,
\r
164 WGL_NEED_PALETTE_ARB,
\r
165 WGL_NEED_SYSTEM_PALETTE_ARB,
\r
166 WGL_SWAP_LAYER_BUFFERS_ARB,
\r
167 WGL_SWAP_METHOD_ARB,
\r
168 WGL_NUMBER_OVERLAYS_ARB,
\r
169 WGL_NUMBER_UNDERLAYS_ARB,
\r
170 WGL_TRANSPARENT_ARB,
\r
171 WGL_TRANSPARENT_RED_VALUE_ARB,
\r
172 WGL_TRANSPARENT_GREEN_VALUE_ARB,
\r
173 WGL_TRANSPARENT_BLUE_VALUE_ARB,
\r
174 WGL_TRANSPARENT_ALPHA_VALUE_ARB,
\r
175 WGL_TRANSPARENT_INDEX_VALUE_ARB,
\r
176 WGL_SHARE_DEPTH_ARB,
\r
177 WGL_SHARE_STENCIL_ARB,
\r
178 WGL_SHARE_ACCUM_ARB,
\r
179 WGL_SUPPORT_GDI_ARB,
\r
180 WGL_SUPPORT_OPENGL_ARB,
\r
181 WGL_DOUBLE_BUFFER_ARB,
\r
183 WGL_PIXEL_TYPE_ARB,
\r
184 WGL_COLOR_BITS_ARB,
\r
187 WGL_GREEN_BITS_ARB,
\r
188 WGL_GREEN_SHIFT_ARB,
\r
190 WGL_BLUE_SHIFT_ARB,
\r
191 WGL_ALPHA_BITS_ARB,
\r
192 WGL_ALPHA_SHIFT_ARB,
\r
193 WGL_ACCUM_BITS_ARB,
\r
194 WGL_ACCUM_RED_BITS_ARB,
\r
195 WGL_ACCUM_GREEN_BITS_ARB,
\r
196 WGL_ACCUM_BLUE_BITS_ARB,
\r
197 WGL_ACCUM_ALPHA_BITS_ARB,
\r
198 WGL_DEPTH_BITS_ARB,
\r
199 WGL_STENCIL_BITS_ARB,
\r
200 WGL_AUX_BUFFERS_ARB
\r
201 #ifdef WGL_ARB_render_texture
\r
202 ,WGL_BIND_TO_TEXTURE_RGB_ARB //40
\r
203 ,WGL_BIND_TO_TEXTURE_RGBA_ARB
\r
205 #ifdef WGL_ARB_pbuffer
\r
206 ,WGL_DRAW_TO_PBUFFER_ARB //42
\r
207 ,WGL_MAX_PBUFFER_PIXELS_ARB
\r
208 ,WGL_MAX_PBUFFER_WIDTH_ARB
\r
209 ,WGL_MAX_PBUFFER_HEIGHT_ARB
\r
211 #ifdef WGL_ARB_framebuffer_sRGB
\r
212 ,WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB //46
\r
214 #ifdef WGL_ARB_multisample
\r
215 ,WGL_SAMPLES_ARB //47
\r
216 ,WGL_SAMPLE_BUFFERS_ARB
\r
218 #ifdef WGL_EXT_depth_float
\r
219 ,WGL_DEPTH_FLOAT_EXT //49
\r
223 size_t nums = sizeof(atts)/sizeof(int);
\r
224 const bool depth_float_supported= (wglExtensions.find("WGL_EXT_depth_float") != -1);
\r
225 if (!depth_float_supported)
\r
227 memmove(&atts[49], &atts[50], (nums-50)*sizeof(int));
\r
230 if (!multi_sample_supported)
\r
232 memmove(&atts[47], &atts[49], (nums-49)*sizeof(int));
\r
235 const bool framebuffer_sRGB_supported= (wglExtensions.find("WGL_ARB_framebuffer_sRGB") != -1);
\r
236 if (!framebuffer_sRGB_supported)
\r
238 memmove(&atts[46], &atts[47], (nums-47)*sizeof(int));
\r
241 const bool pbuffer_supported = (wglExtensions.find("WGL_ARB_pbuffer") != -1);
\r
242 if (!pbuffer_supported)
\r
244 memmove(&atts[42], &atts[46], (nums-46)*sizeof(int));
\r
247 const bool render_texture_supported = (wglExtensions.find("WGL_ARB_render_texture") != -1);
\r
248 if (!render_texture_supported)
\r
250 memmove(&atts[40], &atts[42], (nums-42)*sizeof(int));
\r
253 wglGetPixelFormatAttribiv_ARB(hdc,0,0,1,atts,vals);
\r
254 const int count = vals[0];
\r
255 atts[0]=WGL_DRAW_TO_WINDOW_ARB;
\r
256 for (int i=1; i<count; ++i)
\r
258 memset(vals,0,sizeof(vals));
\r
259 #define tmplog(x,y) os::Printer::log(x, core::stringc(y).c_str())
\r
260 const BOOL res = wglGetPixelFormatAttribiv_ARB(hdc,i,0,(UINT)nums,atts,vals);
\r
263 tmplog("Pixel format ",i);
\r
265 tmplog("Draw to window " , vals[j]);
\r
266 tmplog("Draw to bitmap " , vals[++j]);
\r
268 tmplog("Acceleration " , (vals[j]==WGL_NO_ACCELERATION_ARB?"No":
\r
269 vals[j]==WGL_GENERIC_ACCELERATION_ARB?"Generic":vals[j]==WGL_FULL_ACCELERATION_ARB?"Full":"ERROR"));
\r
270 tmplog("Need palette " , vals[++j]);
\r
271 tmplog("Need system palette " , vals[++j]);
\r
272 tmplog("Swap layer buffers " , vals[++j]);
\r
274 tmplog("Swap method " , (vals[j]==WGL_SWAP_EXCHANGE_ARB?"Exchange":
\r
275 vals[j]==WGL_SWAP_COPY_ARB?"Copy":vals[j]==WGL_SWAP_UNDEFINED_ARB?"Undefined":"ERROR"));
\r
276 tmplog("Number of overlays " , vals[++j]);
\r
277 tmplog("Number of underlays " , vals[++j]);
\r
278 tmplog("Transparent " , vals[++j]);
\r
279 tmplog("Transparent red value " , vals[++j]);
\r
280 tmplog("Transparent green value " , vals[++j]);
\r
281 tmplog("Transparent blue value " , vals[++j]);
\r
282 tmplog("Transparent alpha value " , vals[++j]);
\r
283 tmplog("Transparent index value " , vals[++j]);
\r
284 tmplog("Share depth " , vals[++j]);
\r
285 tmplog("Share stencil " , vals[++j]);
\r
286 tmplog("Share accum " , vals[++j]);
\r
287 tmplog("Support GDI " , vals[++j]);
\r
288 tmplog("Support OpenGL " , vals[++j]);
\r
289 tmplog("Double Buffer " , vals[++j]);
\r
290 tmplog("Stereo Buffer " , vals[++j]);
\r
291 tmplog("Pixel type " , vals[++j]);
\r
292 tmplog("Color bits" , vals[++j]);
\r
293 tmplog("Red bits " , vals[++j]);
\r
294 tmplog("Red shift " , vals[++j]);
\r
295 tmplog("Green bits " , vals[++j]);
\r
296 tmplog("Green shift " , vals[++j]);
\r
297 tmplog("Blue bits " , vals[++j]);
\r
298 tmplog("Blue shift " , vals[++j]);
\r
299 tmplog("Alpha bits " , vals[++j]);
\r
300 tmplog("Alpha Shift " , vals[++j]);
\r
301 tmplog("Accum bits " , vals[++j]);
\r
302 tmplog("Accum red bits " , vals[++j]);
\r
303 tmplog("Accum green bits " , vals[++j]);
\r
304 tmplog("Accum blue bits " , vals[++j]);
\r
305 tmplog("Accum alpha bits " , vals[++j]);
\r
306 tmplog("Depth bits " , vals[++j]);
\r
307 tmplog("Stencil bits " , vals[++j]);
\r
308 tmplog("Aux buffers " , vals[++j]);
\r
309 if (render_texture_supported)
\r
311 tmplog("Bind to texture RGB" , vals[++j]);
\r
312 tmplog("Bind to texture RGBA" , vals[++j]);
\r
314 if (pbuffer_supported)
\r
316 tmplog("Draw to pbuffer" , vals[++j]);
\r
317 tmplog("Max pbuffer pixels " , vals[++j]);
\r
318 tmplog("Max pbuffer width" , vals[++j]);
\r
319 tmplog("Max pbuffer height" , vals[++j]);
\r
321 if (framebuffer_sRGB_supported)
\r
322 tmplog("Framebuffer sRBG capable" , vals[++j]);
\r
323 if (multi_sample_supported)
\r
325 tmplog("Samples " , vals[++j]);
\r
326 tmplog("Sample buffers " , vals[++j]);
\r
328 if (depth_float_supported)
\r
329 tmplog("Depth float" , vals[++j]);
\r
335 #elif defined(IRR_LINUX_DEVICE)
\r
340 void COpenGLExtensionHandler::initExtensions(bool stencilBuffer)
\r
342 const f32 ogl_ver = core::fast_atof(reinterpret_cast<const c8*>(glGetString(GL_VERSION)));
\r
343 Version = static_cast<u16>(core::floor32(ogl_ver)*100+core::round32(core::fract(ogl_ver)*10.0f));
\r
344 if ( Version >= 102)
\r
345 os::Printer::log("OpenGL driver version is 1.2 or better.", ELL_INFORMATION);
\r
347 os::Printer::log("OpenGL driver version is not 1.2 or better.", ELL_WARNING);
\r
350 const char* t = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
\r
356 str = new c8[len+1];
\r
360 for (size_t i=0; i<len; ++i)
\r
362 str[i] = static_cast<char>(t[i]);
\r
367 for (u32 j=0; j<IRR_OpenGL_Feature_Count; ++j)
\r
369 if (!strcmp(OpenGLFeatureStrings[j], p))
\r
371 FeatureAvailable[j] = true;
\r
376 p = p + strlen(p) + 1;
\r
383 TextureCompressionExtension = FeatureAvailable[IRR_ARB_texture_compression];
\r
384 StencilBuffer=stencilBuffer;
\r
386 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
\r
387 #ifdef _IRR_WINDOWS_API_
\r
388 #define IRR_OGL_LOAD_EXTENSION(x) wglGetProcAddress(reinterpret_cast<const char*>(x))
\r
389 #elif defined(_IRR_COMPILE_WITH_SDL_DEVICE_) && !defined(_IRR_COMPILE_WITH_X11_DEVICE_)
\r
390 #define IRR_OGL_LOAD_EXTENSION(x) SDL_GL_GetProcAddress(reinterpret_cast<const char*>(x))
\r
392 // Accessing the correct function is quite complex
\r
393 // All libraries should support the ARB version, however
\r
394 // since GLX 1.4 the non-ARB version is the official one
\r
395 // So we have to check the runtime environment and
\r
396 // choose the proper symbol
\r
397 // In case you still have problems please enable the
\r
398 // next line by uncommenting it
\r
399 // #define _IRR_GETPROCADDRESS_WORKAROUND_
\r
401 #ifndef _IRR_GETPROCADDRESS_WORKAROUND_
\r
402 __GLXextFuncPtr (*IRR_OGL_LOAD_EXTENSION_FUNCP)(const GLubyte*)=0;
\r
403 #ifdef GLX_VERSION_1_4
\r
404 int major=0,minor=0;
\r
405 if (glXGetCurrentDisplay())
\r
406 glXQueryVersion(glXGetCurrentDisplay(), &major, &minor);
\r
407 if ((major>1) || (minor>3))
\r
408 IRR_OGL_LOAD_EXTENSION_FUNCP=glXGetProcAddress;
\r
411 IRR_OGL_LOAD_EXTENSION_FUNCP=glXGetProcAddressARB;
\r
412 #define IRR_OGL_LOAD_EXTENSION(X) IRR_OGL_LOAD_EXTENSION_FUNCP(reinterpret_cast<const GLubyte*>(X))
\r
414 #define IRR_OGL_LOAD_EXTENSION(X) glXGetProcAddressARB(reinterpret_cast<const GLubyte*>(X))
\r
415 #endif // workaround
\r
416 #endif // Windows, SDL, or Linux
\r
418 // get multitexturing function pointers
\r
419 pGlActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) IRR_OGL_LOAD_EXTENSION("glActiveTextureARB");
\r
420 pGlClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) IRR_OGL_LOAD_EXTENSION("glClientActiveTextureARB");
\r
422 // get fragment and vertex program function pointers
\r
423 pGlGenProgramsARB = (PFNGLGENPROGRAMSARBPROC) IRR_OGL_LOAD_EXTENSION("glGenProgramsARB");
\r
424 pGlGenProgramsNV = (PFNGLGENPROGRAMSNVPROC) IRR_OGL_LOAD_EXTENSION("glGenProgramsNV");
\r
425 pGlBindProgramARB = (PFNGLBINDPROGRAMARBPROC) IRR_OGL_LOAD_EXTENSION("glBindProgramARB");
\r
426 pGlBindProgramNV = (PFNGLBINDPROGRAMNVPROC) IRR_OGL_LOAD_EXTENSION("glBindProgramNV");
\r
427 pGlProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC) IRR_OGL_LOAD_EXTENSION("glProgramStringARB");
\r
428 pGlLoadProgramNV = (PFNGLLOADPROGRAMNVPROC) IRR_OGL_LOAD_EXTENSION("glLoadProgramNV");
\r
429 pGlDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC) IRR_OGL_LOAD_EXTENSION("glDeleteProgramsARB");
\r
430 pGlDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC) IRR_OGL_LOAD_EXTENSION("glDeleteProgramsNV");
\r
431 pGlProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) IRR_OGL_LOAD_EXTENSION("glProgramLocalParameter4fvARB");
\r
432 pGlCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC) IRR_OGL_LOAD_EXTENSION("glCreateShaderObjectARB");
\r
433 pGlCreateShader = (PFNGLCREATESHADERPROC) IRR_OGL_LOAD_EXTENSION("glCreateShader");
\r
434 pGlShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) IRR_OGL_LOAD_EXTENSION("glShaderSourceARB");
\r
435 pGlShaderSource = (PFNGLSHADERSOURCEPROC) IRR_OGL_LOAD_EXTENSION("glShaderSource");
\r
436 pGlCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) IRR_OGL_LOAD_EXTENSION("glCompileShaderARB");
\r
437 pGlCompileShader = (PFNGLCOMPILESHADERPROC) IRR_OGL_LOAD_EXTENSION("glCompileShader");
\r
438 pGlCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC) IRR_OGL_LOAD_EXTENSION("glCreateProgramObjectARB");
\r
439 pGlCreateProgram = (PFNGLCREATEPROGRAMPROC) IRR_OGL_LOAD_EXTENSION("glCreateProgram");
\r
440 pGlAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) IRR_OGL_LOAD_EXTENSION("glAttachObjectARB");
\r
441 pGlAttachShader = (PFNGLATTACHSHADERPROC) IRR_OGL_LOAD_EXTENSION("glAttachShader");
\r
442 pGlLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) IRR_OGL_LOAD_EXTENSION("glLinkProgramARB");
\r
443 pGlLinkProgram = (PFNGLLINKPROGRAMPROC) IRR_OGL_LOAD_EXTENSION("glLinkProgram");
\r
444 pGlUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) IRR_OGL_LOAD_EXTENSION("glUseProgramObjectARB");
\r
445 pGlUseProgram = (PFNGLUSEPROGRAMPROC) IRR_OGL_LOAD_EXTENSION("glUseProgram");
\r
446 pGlDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) IRR_OGL_LOAD_EXTENSION("glDeleteObjectARB");
\r
447 pGlDeleteProgram = (PFNGLDELETEPROGRAMPROC) IRR_OGL_LOAD_EXTENSION("glDeleteProgram");
\r
448 pGlDeleteShader = (PFNGLDELETESHADERPROC) IRR_OGL_LOAD_EXTENSION("glDeleteShader");
\r
449 pGlGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC) IRR_OGL_LOAD_EXTENSION("glGetAttachedShaders");
\r
450 pGlGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC) IRR_OGL_LOAD_EXTENSION("glGetAttachedObjectsARB");
\r
451 pGlGetInfoLogARB = (PFNGLGETINFOLOGARBPROC) IRR_OGL_LOAD_EXTENSION("glGetInfoLogARB");
\r
452 pGlGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) IRR_OGL_LOAD_EXTENSION("glGetShaderInfoLog");
\r
453 pGlGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) IRR_OGL_LOAD_EXTENSION("glGetProgramInfoLog");
\r
454 pGlGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC) IRR_OGL_LOAD_EXTENSION("glGetObjectParameterivARB");
\r
455 pGlGetShaderiv = (PFNGLGETSHADERIVPROC) IRR_OGL_LOAD_EXTENSION("glGetShaderiv");
\r
456 pGlGetProgramiv = (PFNGLGETPROGRAMIVPROC) IRR_OGL_LOAD_EXTENSION("glGetProgramiv");
\r
457 pGlGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC) IRR_OGL_LOAD_EXTENSION("glGetUniformLocationARB");
\r
458 pGlGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) IRR_OGL_LOAD_EXTENSION("glGetUniformLocation");
\r
459 pGlUniform1fvARB = (PFNGLUNIFORM1FVARBPROC) IRR_OGL_LOAD_EXTENSION("glUniform1fvARB");
\r
460 pGlUniform2fvARB = (PFNGLUNIFORM2FVARBPROC) IRR_OGL_LOAD_EXTENSION("glUniform2fvARB");
\r
461 pGlUniform3fvARB = (PFNGLUNIFORM3FVARBPROC) IRR_OGL_LOAD_EXTENSION("glUniform3fvARB");
\r
462 pGlUniform4fvARB = (PFNGLUNIFORM4FVARBPROC) IRR_OGL_LOAD_EXTENSION("glUniform4fvARB");
\r
463 pGlUniform1ivARB = (PFNGLUNIFORM1IVARBPROC) IRR_OGL_LOAD_EXTENSION("glUniform1ivARB");
\r
464 pGlUniform2ivARB = (PFNGLUNIFORM2IVARBPROC) IRR_OGL_LOAD_EXTENSION("glUniform2ivARB");
\r
465 pGlUniform3ivARB = (PFNGLUNIFORM3IVARBPROC) IRR_OGL_LOAD_EXTENSION("glUniform3ivARB");
\r
466 pGlUniform4ivARB = (PFNGLUNIFORM4IVARBPROC) IRR_OGL_LOAD_EXTENSION("glUniform4ivARB");
\r
467 pGlUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC) IRR_OGL_LOAD_EXTENSION("glUniformMatrix2fvARB");
\r
468 pGlUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC) IRR_OGL_LOAD_EXTENSION("glUniformMatrix3fvARB");
\r
469 pGlUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC) IRR_OGL_LOAD_EXTENSION("glUniformMatrix4fvARB");
\r
470 pGlGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC) IRR_OGL_LOAD_EXTENSION("glGetActiveUniformARB");
\r
471 pGlGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC) IRR_OGL_LOAD_EXTENSION("glGetActiveUniform");
\r
473 // get point parameter extension
\r
474 pGlPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC) IRR_OGL_LOAD_EXTENSION("glPointParameterfARB");
\r
475 pGlPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC) IRR_OGL_LOAD_EXTENSION("glPointParameterfvARB");
\r
477 // get stencil extension
\r
478 pGlStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) IRR_OGL_LOAD_EXTENSION("glStencilFuncSeparate");
\r
479 pGlStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) IRR_OGL_LOAD_EXTENSION("glStencilOpSeparate");
\r
480 pGlStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC) IRR_OGL_LOAD_EXTENSION("glStencilFuncSeparateATI");
\r
481 pGlStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC) IRR_OGL_LOAD_EXTENSION("glStencilOpSeparateATI");
\r
483 // compressed textures
\r
484 pGlCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) IRR_OGL_LOAD_EXTENSION("glCompressedTexImage2D");
\r
485 pGlCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) IRR_OGL_LOAD_EXTENSION("glCompressedTexSubImage2D");
\r
487 // ARB FrameBufferObjects
\r
488 pGlBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) IRR_OGL_LOAD_EXTENSION("glBindFramebuffer");
\r
489 pGlDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) IRR_OGL_LOAD_EXTENSION("glDeleteFramebuffers");
\r
490 pGlGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) IRR_OGL_LOAD_EXTENSION("glGenFramebuffers");
\r
491 pGlCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) IRR_OGL_LOAD_EXTENSION("glCheckFramebufferStatus");
\r
492 pGlFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) IRR_OGL_LOAD_EXTENSION("glFramebufferTexture2D");
\r
493 pGlBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) IRR_OGL_LOAD_EXTENSION("glBindRenderbuffer");
\r
494 pGlDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) IRR_OGL_LOAD_EXTENSION("glDeleteRenderbuffers");
\r
495 pGlGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) IRR_OGL_LOAD_EXTENSION("glGenRenderbuffers");
\r
496 pGlRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) IRR_OGL_LOAD_EXTENSION("glRenderbufferStorage");
\r
497 pGlFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) IRR_OGL_LOAD_EXTENSION("glFramebufferRenderbuffer");
\r
498 pGlGenerateMipmap = (PFNGLGENERATEMIPMAPPROC) IRR_OGL_LOAD_EXTENSION("glGenerateMipmap");
\r
500 // EXT FrameBufferObjects
\r
501 pGlBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC) IRR_OGL_LOAD_EXTENSION("glBindFramebufferEXT");
\r
502 pGlDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC) IRR_OGL_LOAD_EXTENSION("glDeleteFramebuffersEXT");
\r
503 pGlGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC) IRR_OGL_LOAD_EXTENSION("glGenFramebuffersEXT");
\r
504 pGlCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) IRR_OGL_LOAD_EXTENSION("glCheckFramebufferStatusEXT");
\r
505 pGlFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) IRR_OGL_LOAD_EXTENSION("glFramebufferTexture2DEXT");
\r
506 pGlBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC) IRR_OGL_LOAD_EXTENSION("glBindRenderbufferEXT");
\r
507 pGlDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC) IRR_OGL_LOAD_EXTENSION("glDeleteRenderbuffersEXT");
\r
508 pGlGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC) IRR_OGL_LOAD_EXTENSION("glGenRenderbuffersEXT");
\r
509 pGlRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC) IRR_OGL_LOAD_EXTENSION("glRenderbufferStorageEXT");
\r
510 pGlFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) IRR_OGL_LOAD_EXTENSION("glFramebufferRenderbufferEXT");
\r
511 pGlGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC) IRR_OGL_LOAD_EXTENSION("glGenerateMipmapEXT");
\r
512 pGlDrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC) IRR_OGL_LOAD_EXTENSION("glDrawBuffersARB");
\r
513 pGlDrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC) IRR_OGL_LOAD_EXTENSION("glDrawBuffersATI");
\r
515 // get vertex buffer extension
\r
516 pGlGenBuffersARB = (PFNGLGENBUFFERSARBPROC) IRR_OGL_LOAD_EXTENSION("glGenBuffersARB");
\r
517 pGlBindBufferARB = (PFNGLBINDBUFFERARBPROC) IRR_OGL_LOAD_EXTENSION("glBindBufferARB");
\r
518 pGlBufferDataARB = (PFNGLBUFFERDATAARBPROC) IRR_OGL_LOAD_EXTENSION("glBufferDataARB");
\r
519 pGlDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC) IRR_OGL_LOAD_EXTENSION("glDeleteBuffersARB");
\r
520 pGlBufferSubDataARB= (PFNGLBUFFERSUBDATAARBPROC) IRR_OGL_LOAD_EXTENSION("glBufferSubDataARB");
\r
521 pGlGetBufferSubDataARB= (PFNGLGETBUFFERSUBDATAARBPROC)IRR_OGL_LOAD_EXTENSION("glGetBufferSubDataARB");
\r
522 pGlMapBufferARB= (PFNGLMAPBUFFERARBPROC) IRR_OGL_LOAD_EXTENSION("glMapBufferARB");
\r
523 pGlUnmapBufferARB= (PFNGLUNMAPBUFFERARBPROC) IRR_OGL_LOAD_EXTENSION("glUnmapBufferARB");
\r
524 pGlIsBufferARB= (PFNGLISBUFFERARBPROC) IRR_OGL_LOAD_EXTENSION("glIsBufferARB");
\r
525 pGlGetBufferParameterivARB= (PFNGLGETBUFFERPARAMETERIVARBPROC) IRR_OGL_LOAD_EXTENSION("glGetBufferParameterivARB");
\r
526 pGlGetBufferPointervARB= (PFNGLGETBUFFERPOINTERVARBPROC) IRR_OGL_LOAD_EXTENSION("glGetBufferPointervARB");
\r
527 pGlProvokingVertexARB= (PFNGLPROVOKINGVERTEXPROC) IRR_OGL_LOAD_EXTENSION("glProvokingVertex");
\r
528 pGlProvokingVertexEXT= (PFNGLPROVOKINGVERTEXEXTPROC) IRR_OGL_LOAD_EXTENSION("glProvokingVertexEXT");
\r
529 pGlProgramParameteriARB= (PFNGLPROGRAMPARAMETERIARBPROC) IRR_OGL_LOAD_EXTENSION("glProgramParameteriARB");
\r
530 pGlProgramParameteriEXT= (PFNGLPROGRAMPARAMETERIEXTPROC) IRR_OGL_LOAD_EXTENSION("glProgramParameteriEXT");
\r
533 pGlGenQueriesARB = (PFNGLGENQUERIESARBPROC) IRR_OGL_LOAD_EXTENSION("glGenQueriesARB");
\r
534 pGlDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC) IRR_OGL_LOAD_EXTENSION("glDeleteQueriesARB");
\r
535 pGlIsQueryARB = (PFNGLISQUERYARBPROC) IRR_OGL_LOAD_EXTENSION("glIsQueryARB");
\r
536 pGlBeginQueryARB = (PFNGLBEGINQUERYARBPROC) IRR_OGL_LOAD_EXTENSION("glBeginQueryARB");
\r
537 pGlEndQueryARB = (PFNGLENDQUERYARBPROC) IRR_OGL_LOAD_EXTENSION("glEndQueryARB");
\r
538 pGlGetQueryivARB = (PFNGLGETQUERYIVARBPROC) IRR_OGL_LOAD_EXTENSION("glGetQueryivARB");
\r
539 pGlGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC) IRR_OGL_LOAD_EXTENSION("glGetQueryObjectivARB");
\r
540 pGlGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC) IRR_OGL_LOAD_EXTENSION("glGetQueryObjectuivARB");
\r
541 pGlGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC) IRR_OGL_LOAD_EXTENSION("glGenOcclusionQueriesNV");
\r
542 pGlDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC) IRR_OGL_LOAD_EXTENSION("glDeleteOcclusionQueriesNV");
\r
543 pGlIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC) IRR_OGL_LOAD_EXTENSION("glIsOcclusionQueryNV");
\r
544 pGlBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC) IRR_OGL_LOAD_EXTENSION("glBeginOcclusionQueryNV");
\r
545 pGlEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC) IRR_OGL_LOAD_EXTENSION("glEndOcclusionQueryNV");
\r
546 pGlGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC) IRR_OGL_LOAD_EXTENSION("glGetOcclusionQueryivNV");
\r
547 pGlGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC) IRR_OGL_LOAD_EXTENSION("glGetOcclusionQueryuivNV");
\r
550 pGlBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC) IRR_OGL_LOAD_EXTENSION("glBlendFuncSeparateEXT");
\r
551 pGlBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC) IRR_OGL_LOAD_EXTENSION("glBlendFuncSeparate");
\r
552 pGlBlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC) IRR_OGL_LOAD_EXTENSION("glBlendEquationEXT");
\r
553 pGlBlendEquation = (PFNGLBLENDEQUATIONPROC) IRR_OGL_LOAD_EXTENSION("glBlendEquation");
\r
554 pGlBlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC) IRR_OGL_LOAD_EXTENSION("glBlendEquationSeparateEXT");
\r
555 pGlBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC) IRR_OGL_LOAD_EXTENSION("glBlendEquationSeparate");
\r
558 pGlEnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC) IRR_OGL_LOAD_EXTENSION("glEnableIndexedEXT");
\r
559 pGlDisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC) IRR_OGL_LOAD_EXTENSION("glDisableIndexedEXT");
\r
560 pGlColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC) IRR_OGL_LOAD_EXTENSION("glColorMaskIndexedEXT");
\r
561 pGlBlendFuncIndexedAMD = (PFNGLBLENDFUNCINDEXEDAMDPROC) IRR_OGL_LOAD_EXTENSION("glBlendFuncIndexedAMD");
\r
562 pGlBlendFunciARB = (PFNGLBLENDFUNCIPROC) IRR_OGL_LOAD_EXTENSION("glBlendFunciARB");
\r
563 pGlBlendFuncSeparateIndexedAMD = (PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC) IRR_OGL_LOAD_EXTENSION("glBlendFuncSeparateIndexedAMD");
\r
564 pGlBlendFuncSeparateiARB = (PFNGLBLENDFUNCSEPARATEIPROC) IRR_OGL_LOAD_EXTENSION("glBlendFuncSeparateiARB");
\r
565 pGlBlendEquationIndexedAMD = (PFNGLBLENDEQUATIONINDEXEDAMDPROC) IRR_OGL_LOAD_EXTENSION("glBlendEquationIndexedAMD");
\r
566 pGlBlendEquationiARB = (PFNGLBLENDEQUATIONIPROC) IRR_OGL_LOAD_EXTENSION("glBlendEquationiARB");
\r
567 pGlBlendEquationSeparateIndexedAMD = (PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC) IRR_OGL_LOAD_EXTENSION("glBlendEquationSeparateIndexedAMD");
\r
568 pGlBlendEquationSeparateiARB = (PFNGLBLENDEQUATIONSEPARATEIPROC) IRR_OGL_LOAD_EXTENSION("glBlendEquationSeparateiARB");
\r
570 pGlTextureSubImage2D = (PFNGLTEXTURESUBIMAGE2DPROC)IRR_OGL_LOAD_EXTENSION("glTextureSubImage2D");
\r
571 pGlTextureStorage2D = (PFNGLTEXTURESTORAGE2DPROC) IRR_OGL_LOAD_EXTENSION("glTextureStorage2D");
\r
572 pGlTextureStorage3D = (PFNGLTEXTURESTORAGE3DPROC) IRR_OGL_LOAD_EXTENSION("glTextureStorage3D");
\r
573 pGlNamedFramebufferTexture = (PFNGLNAMEDFRAMEBUFFERTEXTUREPROC) IRR_OGL_LOAD_EXTENSION("glNamedFramebufferTexture");
\r
574 pGlTextureParameteri = (PFNGLTEXTUREPARAMETERIPROC) IRR_OGL_LOAD_EXTENSION("glTextureParameteri");
\r
575 pGlCreateTextures = (PFNGLCREATETEXTURESPROC) IRR_OGL_LOAD_EXTENSION("glCreateTextures");
\r
576 pGlCreateFramebuffers = (PFNGLCREATEFRAMEBUFFERSPROC) IRR_OGL_LOAD_EXTENSION("glCreateFramebuffers");
\r
577 pGlBindTextures = (PFNGLBINDTEXTURESPROC) IRR_OGL_LOAD_EXTENSION("glBindTextures");
\r
578 pGlGenerateTextureMipmap = (PFNGLGENERATETEXTUREMIPMAPPROC) IRR_OGL_LOAD_EXTENSION("glGenerateTextureMipmap");
\r
579 //==============================
\r
580 pGlTextureSubImage2DEXT = (PFNGLTEXTURESUBIMAGE2DEXTPROC)IRR_OGL_LOAD_EXTENSION("glTextureSubImage2DEXT");
\r
581 pGlTextureStorage2DEXT = (PFNGLTEXTURESTORAGE2DEXTPROC)IRR_OGL_LOAD_EXTENSION("glTextureStorage2DEXT");
\r
582 pGlTexStorage2D = (PFNGLTEXSTORAGE2DPROC)IRR_OGL_LOAD_EXTENSION("glTexStorage2D");
\r
583 pGlTextureStorage3DEXT = (PFNGLTEXTURESTORAGE3DEXTPROC)IRR_OGL_LOAD_EXTENSION("glTextureStorage3DEXT");
\r
584 pGlTexStorage3D = (PFNGLTEXSTORAGE3DPROC)IRR_OGL_LOAD_EXTENSION("glTexStorage3D");
\r
585 pGlNamedFramebufferTextureEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC)IRR_OGL_LOAD_EXTENSION("glNamedFramebufferTextureEXT");
\r
586 pGlFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)IRR_OGL_LOAD_EXTENSION("glFramebufferTexture");
\r
587 pGlActiveTexture = (PFNGLACTIVETEXTUREPROC)IRR_OGL_LOAD_EXTENSION("glActiveTexture");
\r
588 pGlGenerateTextureMipmapEXT = (PFNGLGENERATETEXTUREMIPMAPEXTPROC) IRR_OGL_LOAD_EXTENSION("glGenerateTextureMipmapEXT");
\r
590 // get vsync extension
\r
591 #if defined(WGL_EXT_swap_control) && !defined(_IRR_COMPILE_WITH_SDL_DEVICE_)
\r
592 pWglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) IRR_OGL_LOAD_EXTENSION("wglSwapIntervalEXT");
\r
594 #if defined(GLX_SGI_swap_control) && !defined(_IRR_COMPILE_WITH_SDL_DEVICE_)
\r
595 pGlxSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)IRR_OGL_LOAD_EXTENSION("glXSwapIntervalSGI");
\r
597 #if defined(GLX_EXT_swap_control) && !defined(_IRR_COMPILE_WITH_SDL_DEVICE_)
\r
598 pGlxSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)IRR_OGL_LOAD_EXTENSION("glXSwapIntervalEXT");
\r
600 #if defined(GLX_MESA_swap_control) && !defined(_IRR_COMPILE_WITH_SDL_DEVICE_)
\r
601 pGlxSwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)IRR_OGL_LOAD_EXTENSION("glXSwapIntervalMESA");
\r
603 #endif // use extension pointer
\r
606 // set some properties
\r
607 #if defined(GL_ARB_multitexture) || defined(GL_VERSION_1_3)
\r
608 if (Version>102 || FeatureAvailable[IRR_ARB_multitexture])
\r
610 #if defined(GL_MAX_TEXTURE_UNITS)
\r
611 glGetIntegerv(GL_MAX_TEXTURE_UNITS, &num);
\r
612 #elif defined(GL_MAX_TEXTURE_UNITS_ARB)
\r
613 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &num);
\r
615 Feature.MaxTextureUnits=static_cast<u8>(num); // MULTITEXTURING (fixed function pipeline texture units)
\r
618 #if defined(GL_ARB_vertex_shader) || defined(GL_VERSION_2_0)
\r
619 if (Version>=200 || FeatureAvailable[IRR_ARB_vertex_shader])
\r
622 #if defined(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS)
\r
623 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &num);
\r
624 #elif defined(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB)
\r
625 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &num);
\r
627 Feature.MaxTextureUnits =core::max_(Feature.MaxTextureUnits,static_cast<u8>(num));
\r
630 glGetIntegerv(GL_MAX_LIGHTS, &num);
\r
631 MaxLights=static_cast<u8>(num);
\r
632 #ifdef GL_EXT_texture_filter_anisotropic
\r
633 if (FeatureAvailable[IRR_EXT_texture_filter_anisotropic])
\r
635 glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &num);
\r
636 MaxAnisotropy=static_cast<u8>(num);
\r
639 #ifdef GL_VERSION_1_2
\r
642 glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &num);
\r
646 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &num);
\r
647 MaxTextureSize=static_cast<u32>(num);
\r
648 if (queryFeature(EVDF_GEOMETRY_SHADER))
\r
650 #if defined(GL_ARB_geometry_shader4) || defined(GL_EXT_geometry_shader4) || defined(GL_NV_geometry_shader4)
\r
651 glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT, &num);
\r
652 MaxGeometryVerticesOut=static_cast<u32>(num);
\r
653 #elif defined(GL_NV_geometry_program4)
\r
654 extGlGetProgramiv(GEOMETRY_PROGRAM_NV, GL_MAX_PROGRAM_OUTPUT_VERTICES_NV, &num);
\r
655 MaxGeometryVerticesOut=static_cast<u32>(num);
\r
658 #ifdef GL_EXT_texture_lod_bias
\r
659 if (FeatureAvailable[IRR_EXT_texture_lod_bias])
\r
660 glGetFloatv(GL_MAX_TEXTURE_LOD_BIAS_EXT, &MaxTextureLODBias);
\r
662 glGetIntegerv(GL_MAX_CLIP_PLANES, &num);
\r
663 MaxUserClipPlanes=static_cast<u8>(num);
\r
664 glGetIntegerv(GL_AUX_BUFFERS, &num);
\r
665 MaxAuxBuffers=static_cast<u8>(num);
\r
666 #ifdef GL_ARB_draw_buffers
\r
667 if (FeatureAvailable[IRR_ARB_draw_buffers])
\r
669 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &num);
\r
670 Feature.MultipleRenderTarget = static_cast<u8>(num);
\r
673 #if defined(GL_ATI_draw_buffers)
\r
674 #ifdef GL_ARB_draw_buffers
\r
677 if (FeatureAvailable[IRR_ATI_draw_buffers])
\r
679 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ATI, &num);
\r
680 Feature.MultipleRenderTarget = static_cast<u8>(num);
\r
683 #ifdef GL_ARB_framebuffer_object
\r
684 if (FeatureAvailable[IRR_ARB_framebuffer_object])
\r
686 glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &num);
\r
687 Feature.ColorAttachment = static_cast<u8>(num);
\r
690 #if defined(GL_EXT_framebuffer_object)
\r
691 #ifdef GL_ARB_framebuffer_object
\r
694 if (FeatureAvailable[IRR_EXT_framebuffer_object])
\r
696 glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &num);
\r
697 Feature.ColorAttachment = static_cast<u8>(num);
\r
701 glGetFloatv(GL_ALIASED_LINE_WIDTH_RANGE, DimAliasedLine);
\r
702 glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, DimAliasedPoint);
\r
703 glGetFloatv(GL_SMOOTH_LINE_WIDTH_RANGE, DimSmoothedLine);
\r
704 glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, DimSmoothedPoint);
\r
705 #if defined(GL_ARB_shading_language_100) || defined (GL_VERSION_2_0)
\r
706 if (FeatureAvailable[IRR_ARB_shading_language_100] || Version>=200)
\r
708 glGetError(); // clean error buffer
\r
709 #ifdef GL_SHADING_LANGUAGE_VERSION
\r
710 const GLubyte* shaderVersion = glGetString(GL_SHADING_LANGUAGE_VERSION);
\r
712 const GLubyte* shaderVersion = glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
\r
714 if (glGetError() == GL_INVALID_ENUM)
\r
715 ShaderLanguageVersion = 100;
\r
718 const f32 sl_ver = core::fast_atof(reinterpret_cast<const c8*>(shaderVersion));
\r
719 ShaderLanguageVersion = static_cast<u16>(core::floor32(sl_ver)*100+core::round32(core::fract(sl_ver)*10.0f));
\r
724 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
\r
725 if (!pGlActiveTextureARB || !pGlClientActiveTextureARB)
\r
727 Feature.MaxTextureUnits = 1;
\r
728 os::Printer::log("Failed to load OpenGL's multitexture extension, proceeding without.", ELL_WARNING);
\r
732 Feature.MaxTextureUnits = core::min_(Feature.MaxTextureUnits, static_cast<u8>(MATERIAL_MAX_TEXTURES));
\r
733 Feature.MaxTextureUnits = core::min_(Feature.MaxTextureUnits, static_cast<u8>(MATERIAL_MAX_TEXTURES_USED));
\r
735 #ifdef GL_ARB_occlusion_query
\r
736 if (FeatureAvailable[IRR_ARB_occlusion_query])
\r
738 extGlGetQueryiv(GL_SAMPLES_PASSED_ARB,GL_QUERY_COUNTER_BITS_ARB,
\r
740 OcclusionQuerySupport=(num>0);
\r
744 #ifdef GL_NV_occlusion_query
\r
745 if (FeatureAvailable[IRR_NV_occlusion_query])
\r
747 glGetIntegerv(GL_PIXEL_COUNTER_BITS_NV, &num);
\r
748 OcclusionQuerySupport=(num>0);
\r
752 OcclusionQuerySupport=false;
\r
754 Feature.BlendOperation = (Version >= 140) ||
\r
755 FeatureAvailable[IRR_EXT_blend_minmax] ||
\r
756 FeatureAvailable[IRR_EXT_blend_subtract] ||
\r
757 FeatureAvailable[IRR_EXT_blend_logic_op];
\r
760 if (FeatureAvailable[IRR_NVX_gpu_memory_info])
\r
762 // undocumented flags, so use the RAW values
\r
764 glGetIntegerv(0x9047, &val);
\r
765 os::Printer::log("Dedicated video memory (kB)", core::stringc(val));
\r
766 glGetIntegerv(0x9048, &val);
\r
767 os::Printer::log("Total video memory (kB)", core::stringc(val));
\r
768 glGetIntegerv(0x9049, &val);
\r
769 os::Printer::log("Available video memory (kB)", core::stringc(val));
\r
771 #ifdef GL_ATI_meminfo
\r
772 if (FeatureAvailable[IRR_ATI_meminfo])
\r
775 glGetIntegerv(GL_TEXTURE_FREE_MEMORY_ATI, val);
\r
776 os::Printer::log("Free texture memory (kB)", core::stringc(val[0]));
\r
777 glGetIntegerv(GL_VBO_FREE_MEMORY_ATI, val);
\r
778 os::Printer::log("Free VBO memory (kB)", core::stringc(val[0]));
\r
779 glGetIntegerv(GL_RENDERBUFFER_FREE_MEMORY_ATI, val);
\r
780 os::Printer::log("Free render buffer memory (kB)", core::stringc(val[0]));
\r
784 if (queryFeature(EVDF_TEXTURE_CUBEMAP_SEAMLESS))
\r
785 glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
\r
790 const COpenGLCoreFeature& COpenGLExtensionHandler::getFeature() const
\r
795 bool COpenGLExtensionHandler::queryFeature(E_VIDEO_DRIVER_FEATURE feature) const
\r
799 case EVDF_RENDER_TO_TARGET:
\r
801 case EVDF_HARDWARE_TL:
\r
802 return true; // we cannot tell other things
\r
803 case EVDF_MULTITEXTURE:
\r
804 return Feature.MaxTextureUnits > 1;
\r
805 case EVDF_BILINEAR_FILTER:
\r
809 case EVDF_MIP_MAP_AUTO_UPDATE:
\r
810 return FeatureAvailable[IRR_SGIS_generate_mipmap] || FeatureAvailable[IRR_EXT_framebuffer_object] || FeatureAvailable[IRR_ARB_framebuffer_object];
\r
811 case EVDF_STENCIL_BUFFER:
\r
812 return StencilBuffer;
\r
813 case EVDF_VERTEX_SHADER_1_1:
\r
814 case EVDF_ARB_VERTEX_PROGRAM_1:
\r
815 return FeatureAvailable[IRR_ARB_vertex_program] || FeatureAvailable[IRR_NV_vertex_program1_1];
\r
816 case EVDF_PIXEL_SHADER_1_1:
\r
817 case EVDF_PIXEL_SHADER_1_2:
\r
818 case EVDF_ARB_FRAGMENT_PROGRAM_1:
\r
819 return FeatureAvailable[IRR_ARB_fragment_program] || FeatureAvailable[IRR_NV_fragment_program];
\r
820 case EVDF_PIXEL_SHADER_2_0:
\r
821 case EVDF_VERTEX_SHADER_2_0:
\r
822 case EVDF_ARB_GLSL:
\r
823 return (FeatureAvailable[IRR_ARB_shading_language_100]||Version>=200);
\r
824 case EVDF_TEXTURE_NSQUARE:
\r
825 return true; // non-square is always supported
\r
826 case EVDF_TEXTURE_NPOT:
\r
827 // Some ATI cards seem to have only SW support in OpenGL 2.0
\r
828 // drivers if the extension is not exposed, so we skip this
\r
829 // extra test for now!
\r
830 // return (FeatureAvailable[IRR_ARB_texture_non_power_of_two]||Version>=200);
\r
831 return (FeatureAvailable[IRR_ARB_texture_non_power_of_two]);
\r
832 case EVDF_FRAMEBUFFER_OBJECT:
\r
833 return FeatureAvailable[IRR_EXT_framebuffer_object] || FeatureAvailable[IRR_ARB_framebuffer_object];
\r
834 case EVDF_VERTEX_BUFFER_OBJECT:
\r
835 return FeatureAvailable[IRR_ARB_vertex_buffer_object];
\r
836 case EVDF_COLOR_MASK:
\r
838 case EVDF_ALPHA_TO_COVERAGE:
\r
839 return FeatureAvailable[IRR_ARB_multisample];
\r
840 case EVDF_GEOMETRY_SHADER:
\r
841 return FeatureAvailable[IRR_ARB_geometry_shader4] || FeatureAvailable[IRR_EXT_geometry_shader4] || FeatureAvailable[IRR_NV_geometry_program4] || FeatureAvailable[IRR_NV_geometry_shader4];
\r
842 case EVDF_MULTIPLE_RENDER_TARGETS:
\r
843 return FeatureAvailable[IRR_ARB_draw_buffers] || FeatureAvailable[IRR_ATI_draw_buffers];
\r
844 case EVDF_MRT_BLEND:
\r
845 case EVDF_MRT_COLOR_MASK:
\r
846 return FeatureAvailable[IRR_EXT_draw_buffers2];
\r
847 case EVDF_MRT_BLEND_FUNC:
\r
848 return FeatureAvailable[IRR_ARB_draw_buffers_blend] || FeatureAvailable[IRR_AMD_draw_buffers_blend];
\r
849 case EVDF_OCCLUSION_QUERY:
\r
850 return FeatureAvailable[IRR_ARB_occlusion_query] && OcclusionQuerySupport;
\r
851 case EVDF_POLYGON_OFFSET:
\r
852 // both features supported with OpenGL 1.1
\r
853 return Version>=110;
\r
854 case EVDF_BLEND_OPERATIONS:
\r
855 return Feature.BlendOperation;
\r
856 case EVDF_BLEND_SEPARATE:
\r
857 return (Version>=140) || FeatureAvailable[IRR_EXT_blend_func_separate];
\r
858 case EVDF_TEXTURE_MATRIX:
\r
860 case EVDF_TEXTURE_COMPRESSED_DXT:
\r
861 return FeatureAvailable[IRR_EXT_texture_compression_s3tc];
\r
862 case EVDF_TEXTURE_CUBEMAP:
\r
863 return (Version >= 130) || FeatureAvailable[IRR_ARB_texture_cube_map] || FeatureAvailable[IRR_EXT_texture_cube_map];
\r
864 case EVDF_TEXTURE_CUBEMAP_SEAMLESS:
\r
865 return FeatureAvailable[IRR_ARB_seamless_cube_map];
\r
866 case EVDF_DEPTH_CLAMP:
\r
867 return FeatureAvailable[IRR_NV_depth_clamp] || FeatureAvailable[IRR_ARB_depth_clamp];
\r
projects / irrlicht.git / blob