bool InitGLExtention()
{
if (!extensionSupported("GL_ARB_multitexture")) {
printf("Not found GL_ARB_multitexture\n");
return false;
}
if (!extensionSupported("GL_ARB_texture_non_power_of_two")) {
printf("Not found GL_ARB_texture_non_power_of_two\n");
return false;
}
if (!extensionSupported("GL_EXT_framebuffer_object")) {
printf("Not found GL_EXT_framebuffer_object\n");
return false;
}
if (!extensionSupported("GL_ARB_pixel_buffer_object")) {
printf("Not found GL_ARB_pixel_buffer_object\n");
return false;
}
if (!extensionSupported("GL_ARB_shader_objects")) {
printf("Not found GL_ARB_shader_objects\n");
return false;
}
return true;
}
// Initialize WGL-specific extensions
//
static void loadExtensions(void)
{
// Functions for WGL_EXT_extension_string
// NOTE: These are needed by extensionSupported
_glfw.wgl.GetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)
wglGetProcAddress("wglGetExtensionsStringEXT");
_glfw.wgl.GetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)
wglGetProcAddress("wglGetExtensionsStringARB");
// Functions for WGL_ARB_create_context
_glfw.wgl.CreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)
wglGetProcAddress("wglCreateContextAttribsARB");
// Functions for WGL_EXT_swap_control
_glfw.wgl.SwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)
wglGetProcAddress("wglSwapIntervalEXT");
// Functions for WGL_ARB_pixel_format
_glfw.wgl.GetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)
wglGetProcAddress("wglGetPixelFormatAttribivARB");
// This needs to include every extension used below except for
// WGL_ARB_extensions_string and WGL_EXT_extensions_string
_glfw.wgl.ARB_multisample =
extensionSupported("WGL_ARB_multisample");
_glfw.wgl.ARB_framebuffer_sRGB =
extensionSupported("WGL_ARB_framebuffer_sRGB");
_glfw.wgl.EXT_framebuffer_sRGB =
extensionSupported("WGL_EXT_framebuffer_sRGB");
_glfw.wgl.ARB_create_context =
extensionSupported("WGL_ARB_create_context");
_glfw.wgl.ARB_create_context_profile =
extensionSupported("WGL_ARB_create_context_profile");
_glfw.wgl.EXT_create_context_es2_profile =
extensionSupported("WGL_EXT_create_context_es2_profile");
_glfw.wgl.ARB_create_context_robustness =
extensionSupported("WGL_ARB_create_context_robustness");
_glfw.wgl.EXT_swap_control =
extensionSupported("WGL_EXT_swap_control");
_glfw.wgl.ARB_pixel_format =
extensionSupported("WGL_ARB_pixel_format");
_glfw.wgl.ARB_context_flush_control =
extensionSupported("WGL_ARB_context_flush_control");
_glfw.wgl.extensionsLoaded = GLFW_TRUE;
}
const GLint GPUQuery::memoryInfo(const GLenum penum)
{
if(!extensionSupported("GL_NVX_gpu_memory_info"))
return -1;
GLint memory(0); // in kb
glGetIntegerv(penum, &memory);
glError();
return memory;
}
int wglBufferInitialize()
{
if (!extensionSupported("WGL_ARB_buffer_region"))
return FALSE;
/* Look up the 4 functions */
wglCreateBufferRegionARB = (fCreateRegion)wglGetProcAddress("wglCreateBufferRegionARB");
wglSaveBufferRegionARB = (fSaveRegion)wglGetProcAddress("wglSaveBufferRegionARB");
wglRestoreBufferRegionARB = (fRestoreRegion)wglGetProcAddress("wglRestoreBufferRegionARB");
wglDeleteBufferRegionARB = (fDeleteRegion)wglGetProcAddress("wglDeleteBufferRegionARB");
return wglCreateBufferRegionARB && wglDeleteBufferRegionARB && wglSaveBufferRegionARB && wglRestoreBufferRegionARB;
}
void
GLInfo::glInit()
{
_has_GL_ARB_imaging = extensionSupported("GL_ARB_imaging");
GLint stencil_bits;
glGetIntegerv(GL_STENCIL_BITS, &stencil_bits);
#ifdef CLIP_WITH_STENCIL
stencil_max_depth = (1 << stencil_bits)-1;
// std::cerr << DBGVAR(stencil_max_depth) << __FL__;
#endif
glPixelStorei(GL_UNPACK_ALIGNMENT, 8);
}
// Check for required extensions and initialize them if present
bool InitGLExtensions(void)
{
#if 0
if (!extensionSupported("GL_EXT_bgra")) {
Alert("Required OpenGL extension GL_EXT_bgra not supported");
return false;
}
#endif
if (!extensionSupported("GL_ARB_multitexture")) {
Alert("Required OpenGL extension GL_ARB_multitexture not supported");
return false;
}
#if 0
if (!extensionSupported("GL_EXT_texture_env_combine")) {
Alert("Required OpenGL extension GL_EXT_texture_env_combine not supported");
return false;
}
if (!extensionSupported("GL_NV_register_combiners")) {
Alert("Required OpenGL extension GL_NV_register_combiners not supported");
return false;
}
if (!extensionSupported("GL_EXT_texture_cube_map")) {
Alert("Required OpenGL extension GL_EXT_texture_cube_map not supported");
return false;
}
if (!extensionSupported("GL_EXT_separate_specular_color")) {
Alert("Required OpenGL extension GL_EXT_separate_specular_color not supported");
return false;
}
if (!extensionSupported("WGL_EXT_swap_control")) {
Alert("Required OpenGL extension WGL_EXT_swap_control not supported");
return false;
}
#endif
initMultiTexture();
#if 0
initRegisterCombiners();
initSwapControl();
#endif
return true;
}
bool InitGLExtention()
{
// ここで必要なGL Extention関数ポインタを取得する
if (!extensionSupported("GL_ARB_multitexture")) {
printf("Not found GL_ARB_multitexture\n");
return false;
}
else
{
glActiveTexture = (PFNGLACTIVETEXTUREPROC)::wglGetProcAddress("glActiveTexture");
}
if (!extensionSupported("GL_ARB_texture_non_power_of_two")) {
printf("Not found GL_ARB_texture_non_power_of_two\n");
return false;
}
if (!extensionSupported("WGL_ARB_pbuffer")) {
printf("Not found WGL_ARB_pbuffer\n");
return false;
}
else
{
wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)::wglGetProcAddress("wglCreatePbufferARB");
wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)::wglGetProcAddress("wglGetPbufferDCARB");
wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)::wglGetProcAddress("wglReleasePbufferDCARB");
wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)::wglGetProcAddress("wglDestroyPbufferARB");
wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)::wglGetProcAddress("wglQueryPbufferARB");
wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)::wglGetProcAddress("wglGetPixelFormatAttribivARB");
}
if (!extensionSupported("GL_EXT_framebuffer_object")) {
printf("Not found GL_EXT_framebuffer_object\n");
return false;
}
else
{
glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)wglGetProcAddress("glGenFramebuffersEXT");
glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)wglGetProcAddress("glDeleteFramebuffersEXT");
glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)wglGetProcAddress("glBindFramebufferEXT");
glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)wglGetProcAddress("glFramebufferTexture2DEXT");
glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)wglGetProcAddress("glGenRenderbuffersEXT");
glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)wglGetProcAddress("glDeleteRenderbuffersEXT");
glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)wglGetProcAddress("glBindRenderbufferEXT");
glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)wglGetProcAddress("glRenderbufferStorageEXT");
glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)wglGetProcAddress("glFramebufferRenderbufferEXT");
glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)wglGetProcAddress("glCheckFramebufferStatusEXT");
}
// check PBO is supported by your video card
if (!extensionSupported("GL_ARB_pixel_buffer_object")) {
printf("Not found GL_ARB_pixel_buffer_object");
return false;
}
else
{
// get pointers to GL functions
glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)wglGetProcAddress("glGenBuffersARB");
glBindBufferARB = (PFNGLBINDBUFFERARBPROC)wglGetProcAddress("glBindBufferARB");
glBufferDataARB = (PFNGLBUFFERDATAARBPROC)wglGetProcAddress("glBufferDataARB");
glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)wglGetProcAddress("glBufferSubDataARB");
glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)wglGetProcAddress("glDeleteBuffersARB");
glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)wglGetProcAddress("glGetBufferParameterivARB");
glMapBufferARB = (PFNGLMAPBUFFERARBPROC)wglGetProcAddress("glMapBufferARB");
glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)wglGetProcAddress("glUnmapBufferARB");
}
if (!extensionSupported("GL_ARB_shader_objects")) {
printf("Not found GL_ARB_shader_objects");
return false;
}
else
{
glCreateShader = (PFNGLCREATESHADERPROC)wglGetProcAddress("glCreateShader");
glShaderSource = (PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource");
glCompileShader = (PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader");
glGetShaderiv = (PFNGLGETSHADERIVPROC)wglGetProcAddress("glGetShaderiv");
glDeleteShader = (PFNGLDELETESHADERPROC)wglGetProcAddress("glDeleteShader");
glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)wglGetProcAddress("glGetShaderInfoLog");
glCreateProgram = (PFNGLCREATEPROGRAMPROC)wglGetProcAddress("glCreateProgram");
glAttachShader = (PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader");
glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)wglGetProcAddress("glGetAttachedShaders");
glLinkProgram = (PFNGLLINKPROGRAMPROC)wglGetProcAddress("glLinkProgram");
glGetProgramiv = (PFNGLGETPROGRAMIVPROC)wglGetProcAddress("glGetProgramiv");
glUseProgram = (PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram");
glDetachShader = (PFNGLDETACHSHADERPROC)wglGetProcAddress("glDetachShader");
glDeleteProgram = (PFNGLDELETEPROGRAMPROC)wglGetProcAddress("glDeleteProgram");
glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)wglGetProcAddress("glGetProgramInfoLog");
glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)wglGetProcAddress("glGetAttribLocation");
// get vertex attribute function pointers
glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)wglGetProcAddress("glEnableVertexAttribArray");
glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)wglGetProcAddress("glDisableVertexAttribArray");
glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)wglGetProcAddress("glVertexAttribPointer");
glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)wglGetProcAddress("glGetActiveAttrib");
glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)wglGetProcAddress("glBindAttribLocation");
// uniforms
glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)wglGetProcAddress("glGetUniformLocation");
glUniform1i = (PFNGLUNIFORM1IPROC)wglGetProcAddress("glUniform1i");
glUniform2i = (PFNGLUNIFORM2IPROC)wglGetProcAddress("glUniform2i");
glUniform3i = (PFNGLUNIFORM3IPROC)wglGetProcAddress("glUniform3i");
glUniform4i = (PFNGLUNIFORM4IPROC)wglGetProcAddress("glUniform4i");
glUniform1iv = (PFNGLUNIFORM1IVPROC)wglGetProcAddress("glUniform1iv");
glUniform2iv = (PFNGLUNIFORM2IVPROC)wglGetProcAddress("glUniform2iv");
glUniform3iv = (PFNGLUNIFORM3IVPROC)wglGetProcAddress("glUniform3iv");
glUniform4iv = (PFNGLUNIFORM4IVPROC)wglGetProcAddress("glUniform4iv");
glUniform1f = (PFNGLUNIFORM1FPROC)wglGetProcAddress("glUniform1f");
glUniform2f = (PFNGLUNIFORM2FPROC)wglGetProcAddress("glUniform2f");
glUniform3f = (PFNGLUNIFORM3FPROC)wglGetProcAddress("glUniform3f");
glUniform4f = (PFNGLUNIFORM4FPROC)wglGetProcAddress("glUniform4f");
glUniform1fv = (PFNGLUNIFORM1FVPROC)wglGetProcAddress("glUniform1fv");
glUniform2fv = (PFNGLUNIFORM2FVPROC)wglGetProcAddress("glUniform2fv");
glUniform3fv = (PFNGLUNIFORM3FVPROC)wglGetProcAddress("glUniform3fv");
glUniform4fv = (PFNGLUNIFORM4FVPROC)wglGetProcAddress("glUniform4fv");
glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)wglGetProcAddress("glUniformMatrix2fv");
glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)wglGetProcAddress("glUniformMatrix3fv");
glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)wglGetProcAddress("glUniformMatrix4fv");
glProgramParameteri = (PFNGLPROGRAMPARAMETERIEXTPROC)wglGetProcAddress("glProgramParameteri");
}
return true;
}
const bool GPUQuery::extensionSupported(const QString & extension)
{
QByteArray b(extension.toLocal8Bit());
return extensionSupported(b.constData());
}
//-------------------------------------------------------------
// GLSupport::gl_init() initialize
//-------------------------------------------------------------
void GLSupport::gl_init()
{
static int initialized=0;
if(!initialized){
const GLubyte *version=glGetString(GL_VERSION);
const GLubyte *glsl_version=glGetString(GL_SHADING_LANGUAGE_VERSION);
gl_version=10*(version[0]-'0');
gl_version+=version[2]-'0';
ARB_multitexture_supported=extensionSupported("GL_ARB_multitexture");
ARB_texture_env_combine_supported=extensionSupported("GL_ARB_texture_env_combine");
ARB_texture_cube_map_supported=extensionSupported("GL_ARB_texture_cube_map");
ARB_texture_env_dot3_supported=extensionSupported("GL_ARB_texture_env_dot3");
ARB_shading_language_100_supported=extensionSupported("GL_ARB_shading_language_100");
ARB_shader_objects_supported=extensionSupported("GL_ARB_shader_objects");
EXT_framebuffer_object_supported=extensionSupported("GL_EXT_framebuffer_object");
ARB_geometry_shader4_supported=extensionSupported("GL_ARB_geometry_shader4");
printf("OGL version : %s (%d)\n",version,gl_version);
printf("GLSL version : %s \n",glsl_version);
#ifdef SHOW_ALL_EXTENSIONS
const GLubyte *exts=glGetString(GL_EXTENSIONS);
printf("%s\n",exts);
#endif
initialized=1;
}
setContext();
// make white texture for ogl1.1 specular pass
//if(gl_version==11){
// glGenTextures (1, &white_texture);
// glBindTexture (GL_TEXTURE_2D, white_texture);
//}
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST );
//glHint(GL_POINT_SMOOTH_HINT, GL_NICEST );
//glPolygonOffset(0.1,1);
//glEnable(GL_POLYGON_OFFSET_FILL);
int auxbufs=0;
glGetIntegerv(GL_SAMPLE_BUFFERS_ARB,&auxbufs);
//glEnable(GL_POLYGON_SMOOTH);
//glEnable(GL_NORMALIZE);
// unsigned char pixels[2*2*4];
//memset (pixels, 0xff, 2*2*4);
//glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 2, 2,
// 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
txchnls=1;
if(multiTextures()){
#ifdef GL_MAX_TEXTURE_UNITS_ARB
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB,&txchnls);
#else
#ifdef GL_MAX_ACTIVE_TEXTURES_ARB
glGetIntegerv(GL_MAX_ACTIVE_TEXTURES_ARB,&txchnls);
#endif
#endif
printf("max multi-texture channels = %d\n",txchnls);
}
else
printf(" multi-textures support disabled\n");
if(glsl()){
printf("GLSL supported\n");
if(geometry_shader())
printf("Geometry shader supported\n");
else
printf("Geometry shader NOT supported\n");
if(renderTextures())
printf("Render to Texture supported\n");
else
printf("Render to Texture NOT supported\n");
}
else
printf("GLSL NOT supported\n");
set_spectex(1);
}
// Initialize EGL
//
GLFWbool _glfwInitEGL(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_WIN32)
"libEGL.dll",
"EGL.dll",
#elif defined(_GLFW_COCOA)
"libEGL.dylib",
#else
"libEGL.so.1",
#endif
NULL
};
for (i = 0; sonames[i]; i++)
{
_glfw.egl.handle = _glfw_dlopen(sonames[i]);
if (_glfw.egl.handle)
break;
}
if (!_glfw.egl.handle)
return GLFW_FALSE;
_glfw.egl.GetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC)
_glfw_dlsym(_glfw.egl.handle, "eglGetConfigAttrib");
_glfw.egl.GetConfigs = (PFNEGLGETCONFIGSPROC)
_glfw_dlsym(_glfw.egl.handle, "eglGetConfigs");
_glfw.egl.GetDisplay = (PFNEGLGETDISPLAYPROC)
_glfw_dlsym(_glfw.egl.handle, "eglGetDisplay");
_glfw.egl.GetError = (PFNEGLGETERRORPROC)
_glfw_dlsym(_glfw.egl.handle, "eglGetError");
_glfw.egl.Initialize = (PFNEGLINITIALIZEPROC)
_glfw_dlsym(_glfw.egl.handle, "eglInitialize");
_glfw.egl.Terminate = (PFNEGLTERMINATEPROC)
_glfw_dlsym(_glfw.egl.handle, "eglTerminate");
_glfw.egl.BindAPI = (PFNEGLBINDAPIPROC)
_glfw_dlsym(_glfw.egl.handle, "eglBindAPI");
_glfw.egl.CreateContext = (PFNEGLCREATECONTEXTPROC)
_glfw_dlsym(_glfw.egl.handle, "eglCreateContext");
_glfw.egl.DestroySurface = (PFNEGLDESTROYSURFACEPROC)
_glfw_dlsym(_glfw.egl.handle, "eglDestroySurface");
_glfw.egl.DestroyContext = (PFNEGLDESTROYCONTEXTPROC)
_glfw_dlsym(_glfw.egl.handle, "eglDestroyContext");
_glfw.egl.CreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC)
_glfw_dlsym(_glfw.egl.handle, "eglCreateWindowSurface");
_glfw.egl.MakeCurrent = (PFNEGLMAKECURRENTPROC)
_glfw_dlsym(_glfw.egl.handle, "eglMakeCurrent");
_glfw.egl.SwapBuffers = (PFNEGLSWAPBUFFERSPROC)
_glfw_dlsym(_glfw.egl.handle, "eglSwapBuffers");
_glfw.egl.SwapInterval = (PFNEGLSWAPINTERVALPROC)
_glfw_dlsym(_glfw.egl.handle, "eglSwapInterval");
_glfw.egl.QueryString = (PFNEGLQUERYSTRINGPROC)
_glfw_dlsym(_glfw.egl.handle, "eglQueryString");
_glfw.egl.GetProcAddress = (PFNEGLGETPROCADDRESSPROC)
_glfw_dlsym(_glfw.egl.handle, "eglGetProcAddress");
// For EGLDevice backend the display gets initialized
// in _glfwPlatformInit()
#if !defined(_GLFW_EGLDEVICE)
_glfw.egl.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
if (_glfw.egl.display == EGL_NO_DISPLAY)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to get EGL display: %s",
getErrorString(eglGetError()));
_glfwTerminateEGL();
return GLFW_FALSE;
}
if (!eglInitialize(_glfw.egl.display, &_glfw.egl.major, &_glfw.egl.minor))
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to initialize EGL: %s",
getErrorString(eglGetError()));
_glfwTerminateEGL();
return GLFW_FALSE;
}
#endif
_glfw.egl.KHR_create_context =
extensionSupported("EGL_KHR_create_context");
_glfw.egl.KHR_create_context_no_error =
extensionSupported("EGL_KHR_create_context_no_error");
_glfw.egl.KHR_gl_colorspace =
extensionSupported("EGL_KHR_gl_colorspace");
return GLFW_TRUE;
}
// Initialize GLX
//
GLFWbool _glfwInitGLX(void)
{
int i;
const char* sonames[] =
{
#if defined(__CYGWIN__)
"libGL-1.so",
#else
"libGL.so.1",
"libGL.so",
#endif
NULL
};
for (i = 0; sonames[i]; i++)
{
_glfw.glx.handle = dlopen(sonames[i], RTLD_LAZY | RTLD_GLOBAL);
if (_glfw.glx.handle)
break;
}
if (!_glfw.glx.handle)
{
_glfwInputError(GLFW_API_UNAVAILABLE, "GLX: Failed to load GLX");
return GLFW_FALSE;
}
_glfw.glx.GetFBConfigs =
dlsym(_glfw.glx.handle, "glXGetFBConfigs");
_glfw.glx.GetFBConfigAttrib =
dlsym(_glfw.glx.handle, "glXGetFBConfigAttrib");
_glfw.glx.GetClientString =
dlsym(_glfw.glx.handle, "glXGetClientString");
_glfw.glx.QueryExtension =
dlsym(_glfw.glx.handle, "glXQueryExtension");
_glfw.glx.QueryVersion =
dlsym(_glfw.glx.handle, "glXQueryVersion");
_glfw.glx.DestroyContext =
dlsym(_glfw.glx.handle, "glXDestroyContext");
_glfw.glx.MakeCurrent =
dlsym(_glfw.glx.handle, "glXMakeCurrent");
_glfw.glx.SwapBuffers =
dlsym(_glfw.glx.handle, "glXSwapBuffers");
_glfw.glx.QueryExtensionsString =
dlsym(_glfw.glx.handle, "glXQueryExtensionsString");
_glfw.glx.CreateNewContext =
dlsym(_glfw.glx.handle, "glXCreateNewContext");
_glfw.glx.CreateWindow =
dlsym(_glfw.glx.handle, "glXCreateWindow");
_glfw.glx.DestroyWindow =
dlsym(_glfw.glx.handle, "glXDestroyWindow");
_glfw.glx.GetProcAddress =
dlsym(_glfw.glx.handle, "glXGetProcAddress");
_glfw.glx.GetProcAddressARB =
dlsym(_glfw.glx.handle, "glXGetProcAddressARB");
_glfw.glx.GetVisualFromFBConfig =
dlsym(_glfw.glx.handle, "glXGetVisualFromFBConfig");
if (!glXQueryExtension(_glfw.x11.display,
&_glfw.glx.errorBase,
&_glfw.glx.eventBase))
{
_glfwInputError(GLFW_API_UNAVAILABLE, "GLX: GLX extension not found");
return GLFW_FALSE;
}
if (!glXQueryVersion(_glfw.x11.display, &_glfw.glx.major, &_glfw.glx.minor))
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"GLX: Failed to query GLX version");
return GLFW_FALSE;
}
if (_glfw.glx.major == 1 && _glfw.glx.minor < 3)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"GLX: GLX version 1.3 is required");
return GLFW_FALSE;
}
if (extensionSupported("GLX_EXT_swap_control"))
{
_glfw.glx.SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)
getProcAddress("glXSwapIntervalEXT");
if (_glfw.glx.SwapIntervalEXT)
_glfw.glx.EXT_swap_control = GLFW_TRUE;
}
if (extensionSupported("GLX_SGI_swap_control"))
{
_glfw.glx.SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)
getProcAddress("glXSwapIntervalSGI");
if (_glfw.glx.SwapIntervalSGI)
_glfw.glx.SGI_swap_control = GLFW_TRUE;
}
if (extensionSupported("GLX_MESA_swap_control"))
{
_glfw.glx.SwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)
getProcAddress("glXSwapIntervalMESA");
if (_glfw.glx.SwapIntervalMESA)
_glfw.glx.MESA_swap_control = GLFW_TRUE;
}
if (extensionSupported("GLX_ARB_multisample"))
_glfw.glx.ARB_multisample = GLFW_TRUE;
if (extensionSupported("GLX_ARB_framebuffer_sRGB"))
_glfw.glx.ARB_framebuffer_sRGB = GLFW_TRUE;
if (extensionSupported("GLX_EXT_framebuffer_sRGB"))
_glfw.glx.EXT_framebuffer_sRGB = GLFW_TRUE;
if (extensionSupported("GLX_ARB_create_context"))
{
_glfw.glx.CreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)
getProcAddress("glXCreateContextAttribsARB");
if (_glfw.glx.CreateContextAttribsARB)
_glfw.glx.ARB_create_context = GLFW_TRUE;
}
if (extensionSupported("GLX_ARB_create_context_robustness"))
_glfw.glx.ARB_create_context_robustness = GLFW_TRUE;
if (extensionSupported("GLX_ARB_create_context_profile"))
_glfw.glx.ARB_create_context_profile = GLFW_TRUE;
if (extensionSupported("GLX_EXT_create_context_es2_profile"))
_glfw.glx.EXT_create_context_es2_profile = GLFW_TRUE;
if (extensionSupported("GLX_ARB_context_flush_control"))
_glfw.glx.ARB_context_flush_control = GLFW_TRUE;
return GLFW_TRUE;
}
bool InitializeExtensions() {
// If we've already initialised, we're done
if( glInitialised)
return extensionsAvailable;
glInitialised = true;
#ifdef _HARDWARE_RENDERER_AVAILABLE_
// Make sure we have a Maya OpenGL context setup
// The hardware renderer is the most reliable one to try
MHardwareRenderer *pRenderer = MHardwareRenderer::theRenderer();
if (pRenderer) {
const MString & backEndStr = pRenderer->backEndString();
unsigned int width = 64, height = 64;
MStatus status = pRenderer->makeSwatchContextCurrent( backEndStr,
width,
height );
if (status != MStatus::kSuccess) {
MGlobal::displayError(MString("Unqualified video card : Offscreen contexts not supported. Ashli Shader plugin will not be loaded."));
return false;
}
}
else {
MGlobal::displayError(MString("Unqualified video card. Ashli Shader plugin will not be loaded."));
return false;
}
#endif
int ver = GLversion();
const char *extensions = (const char*)glGetString(GL_EXTENSIONS);
if ( 0) { //turning off looking for GL 2.0 versions right now
//query for the OpenGL 2.0 version of the entrypoints
//
//This section needs to be rewritten to properly handle the minor name mangling
//that occurred in promoting the extensions to core. Lots of entrypoints lost
//"object" from the name, and some were forked to deal specifically with shaders
//and programs.
//
glShadingLanguageSupport = true;
glMultiTextureSupport = true;
glTexture3DSupport = true;
SAFE_GET_PROC( PFNGLDELETEOBJECTARBPROC, glDeleteObject, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETHANDLEARBPROC, glGetHandle, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLDETACHOBJECTARBPROC, glDetachObject, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLCREATESHADEROBJECTARBPROC, glCreateShaderObject, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLSHADERSOURCEARBPROC, glShaderSource, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLCOMPILESHADERARBPROC, glCompileShader, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLCREATEPROGRAMOBJECTARBPROC, glCreateProgramObject, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLATTACHOBJECTARBPROC, glAttachObject, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLLINKPROGRAMARBPROC, glLinkProgram, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUSEPROGRAMOBJECTARBPROC, glUseProgramObject, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVALIDATEPROGRAMARBPROC, glValidateProgram, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM1FARBPROC, glUniform1f, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM2FARBPROC, glUniform2f, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM3FARBPROC, glUniform3f, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM4FARBPROC, glUniform4f, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM1IARBPROC, glUniform1i, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM2IARBPROC, glUniform2i, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM3IARBPROC, glUniform3i, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM4IARBPROC, glUniform4i, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM1FVARBPROC, glUniform1fv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM2FVARBPROC, glUniform2fv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM3FVARBPROC, glUniform3fv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM4FVARBPROC, glUniform4fv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM1IVARBPROC, glUniform1iv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM2IVARBPROC, glUniform2iv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM3IVARBPROC, glUniform3iv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORM4IVARBPROC, glUniform4iv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORMMATRIX2FVARBPROC, glUniformMatrix2fv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORMMATRIX3FVARBPROC, glUniformMatrix3fv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLUNIFORMMATRIX4FVARBPROC, glUniformMatrix4fv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETOBJECTPARAMETERFVARBPROC, glGetObjectParameterfv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETOBJECTPARAMETERIVARBPROC, glGetObjectParameteriv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETINFOLOGARBPROC, glGetInfoLog, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETATTACHEDOBJECTSARBPROC, glGetAttachedObjects, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETUNIFORMLOCATIONARBPROC, glGetUniformLocation, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETACTIVEUNIFORMARBPROC, glGetActiveUniform, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETUNIFORMFVARBPROC, glGetUniformfv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETUNIFORMIVARBPROC, glGetUniformiv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETSHADERSOURCEARBPROC, glGetShaderSource, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLBINDATTRIBLOCATIONARBPROC, glBindAttribLocation, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETACTIVEATTRIBARBPROC, glGetActiveAttrib, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETATTRIBLOCATIONARBPROC, glGetAttribLocation, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB1SARBPROC, glVertexAttrib1s, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB1FARBPROC, glVertexAttrib1f, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB1DARBPROC, glVertexAttrib1d, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB2SARBPROC, glVertexAttrib2s, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB2FARBPROC, glVertexAttrib2f, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB2DARBPROC, glVertexAttrib2d, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB3SARBPROC, glVertexAttrib3s, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB3FARBPROC, glVertexAttrib3f, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB3DARBPROC, glVertexAttrib3d, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4SARBPROC, glVertexAttrib4s, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4FARBPROC, glVertexAttrib4f, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4DARBPROC, glVertexAttrib4d, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4NUBARBPROC, glVertexAttrib4Nub, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB1SVARBPROC, glVertexAttrib1sv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB1FVARBPROC, glVertexAttrib1fv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB1DVARBPROC, glVertexAttrib1dv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB2SVARBPROC, glVertexAttrib2sv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB2FVARBPROC, glVertexAttrib2fv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB2DVARBPROC, glVertexAttrib2dv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB3SVARBPROC, glVertexAttrib3sv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB3FVARBPROC, glVertexAttrib3fv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB3DVARBPROC, glVertexAttrib3dv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4SVARBPROC, glVertexAttrib4sv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4FVARBPROC, glVertexAttrib4fv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4DVARBPROC, glVertexAttrib4dv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4IVARBPROC, glVertexAttrib4iv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4BVARBPROC, glVertexAttrib4bv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4USVARBPROC, glVertexAttrib4usv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4UBVARBPROC, glVertexAttrib4ubv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4UIVARBPROC, glVertexAttrib4uiv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4NBVARBPROC, glVertexAttrib4Nbv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4NSVARBPROC, glVertexAttrib4Nsv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4NIVARBPROC, glVertexAttrib4Niv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4NUBVARBPROC, glVertexAttrib4Nubv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4NUSVARBPROC, glVertexAttrib4Nusv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIB4NUIVARBPROC, glVertexAttrib4Nuiv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLVERTEXATTRIBPOINTERARBPROC, glVertexAttribPointer, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLENABLEVERTEXATTRIBARRAYARBPROC, glEnableVertexAttribArray, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLDISABLEVERTEXATTRIBARRAYARBPROC, glDisableVertexAttribArray, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETVERTEXATTRIBDVARBPROC, glGetVertexAttribdv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETVERTEXATTRIBFVARBPROC, glGetVertexAttribfv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETVERTEXATTRIBIVARBPROC, glGetVertexAttribiv, glShadingLanguageSupport);
SAFE_GET_PROC( PFNGLGETVERTEXATTRIBPOINTERVARBPROC, glGetVertexAttribPointerv, glShadingLanguageSupport);
#ifdef WIN32
SAFE_GET_PROC( PFNGLACTIVETEXTUREPROC, glActiveTexture, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLCLIENTACTIVETEXTUREPROC, glClientActiveTexture, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1DPROC, glMultiTexCoord1d, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1DVPROC, glMultiTexCoord1dv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1FPROC, glMultiTexCoord1f, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1FVPROC, glMultiTexCoord1fv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1IPROC, glMultiTexCoord1i, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1IVPROC, glMultiTexCoord1iv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1SPROC, glMultiTexCoord1s, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1SVPROC, glMultiTexCoord1sv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2DPROC, glMultiTexCoord2d, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2DVPROC, glMultiTexCoord2dv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2FPROC, glMultiTexCoord2f, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2FVPROC, glMultiTexCoord2fv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2IPROC, glMultiTexCoord2i, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2IVPROC, glMultiTexCoord2iv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2SPROC, glMultiTexCoord2s, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2SVPROC, glMultiTexCoord2sv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3DPROC, glMultiTexCoord3d, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3DVPROC, glMultiTexCoord3dv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3FPROC, glMultiTexCoord3f, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3FVPROC, glMultiTexCoord3fv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3IPROC, glMultiTexCoord3i, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3IVPROC, glMultiTexCoord3iv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3SPROC, glMultiTexCoord3s, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3SVPROC, glMultiTexCoord3sv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4DPROC, glMultiTexCoord4d, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4DVPROC, glMultiTexCoord4dv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4FPROC, glMultiTexCoord4f, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4FVPROC, glMultiTexCoord4fv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4IPROC, glMultiTexCoord4i, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4IVPROC, glMultiTexCoord4iv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4SPROC, glMultiTexCoord4s, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4SVPROC, glMultiTexCoord4sv, glMultiTextureSupport);
#endif
#ifdef WIN32
SAFE_GET_PROC( PFNGLTEXIMAGE3DEXTPROC, glTexImage3D, glTexture3DSupport);
SAFE_GET_PROC( PFNGLTEXSUBIMAGE3DPROC, glTexSubImage3D, glTexture3DSupport);
SAFE_GET_PROC( PFNGLCOPYTEXSUBIMAGE3DPROC, glCopyTexSubImage3D, glTexture3DSupport);
#endif
}
else {
//look for the ARB extensions
if ( extensionSupported( extensions, "GL_ARB_shader_objects") ) {
glShadingLanguageSupport = true;
SAFE_GET_PROC_ARB( PFNGLDELETEOBJECTARBPROC, glDeleteObject, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETHANDLEARBPROC, glGetHandle, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLDETACHOBJECTARBPROC, glDetachObject, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLCREATESHADEROBJECTARBPROC, glCreateShaderObject, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLSHADERSOURCEARBPROC, glShaderSource, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLCOMPILESHADERARBPROC, glCompileShader, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLCREATEPROGRAMOBJECTARBPROC, glCreateProgramObject, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLATTACHOBJECTARBPROC, glAttachObject, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLLINKPROGRAMARBPROC, glLinkProgram, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUSEPROGRAMOBJECTARBPROC, glUseProgramObject, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVALIDATEPROGRAMARBPROC, glValidateProgram, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM1FARBPROC, glUniform1f, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM2FARBPROC, glUniform2f, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM3FARBPROC, glUniform3f, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM4FARBPROC, glUniform4f, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM1IARBPROC, glUniform1i, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM2IARBPROC, glUniform2i, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM3IARBPROC, glUniform3i, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM4IARBPROC, glUniform4i, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM1FVARBPROC, glUniform1fv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM2FVARBPROC, glUniform2fv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM3FVARBPROC, glUniform3fv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM4FVARBPROC, glUniform4fv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM1IVARBPROC, glUniform1iv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM2IVARBPROC, glUniform2iv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM3IVARBPROC, glUniform3iv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORM4IVARBPROC, glUniform4iv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORMMATRIX2FVARBPROC, glUniformMatrix2fv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORMMATRIX3FVARBPROC, glUniformMatrix3fv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLUNIFORMMATRIX4FVARBPROC, glUniformMatrix4fv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETOBJECTPARAMETERFVARBPROC, glGetObjectParameterfv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETOBJECTPARAMETERIVARBPROC, glGetObjectParameteriv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETINFOLOGARBPROC, glGetInfoLog, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETATTACHEDOBJECTSARBPROC, glGetAttachedObjects, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETUNIFORMLOCATIONARBPROC, glGetUniformLocation, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETACTIVEUNIFORMARBPROC, glGetActiveUniform, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETUNIFORMFVARBPROC, glGetUniformfv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETUNIFORMIVARBPROC, glGetUniformiv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETSHADERSOURCEARBPROC, glGetShaderSource, glShadingLanguageSupport);
if ( extensionSupported( extensions, "GL_ARB_vertex_shader") ) {
SAFE_GET_PROC_ARB( PFNGLBINDATTRIBLOCATIONARBPROC, glBindAttribLocation, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETACTIVEATTRIBARBPROC, glGetActiveAttrib, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETATTRIBLOCATIONARBPROC, glGetAttribLocation, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB1SARBPROC, glVertexAttrib1s, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB1FARBPROC, glVertexAttrib1f, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB1DARBPROC, glVertexAttrib1d, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB2SARBPROC, glVertexAttrib2s, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB2FARBPROC, glVertexAttrib2f, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB2DARBPROC, glVertexAttrib2d, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB3SARBPROC, glVertexAttrib3s, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB3FARBPROC, glVertexAttrib3f, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB3DARBPROC, glVertexAttrib3d, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4SARBPROC, glVertexAttrib4s, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4FARBPROC, glVertexAttrib4f, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4DARBPROC, glVertexAttrib4d, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4NUBARBPROC, glVertexAttrib4Nub, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB1SVARBPROC, glVertexAttrib1sv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB1FVARBPROC, glVertexAttrib1fv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB1DVARBPROC, glVertexAttrib1dv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB2SVARBPROC, glVertexAttrib2sv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB2FVARBPROC, glVertexAttrib2fv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB2DVARBPROC, glVertexAttrib2dv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB3SVARBPROC, glVertexAttrib3sv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB3FVARBPROC, glVertexAttrib3fv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB3DVARBPROC, glVertexAttrib3dv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4SVARBPROC, glVertexAttrib4sv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4FVARBPROC, glVertexAttrib4fv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4DVARBPROC, glVertexAttrib4dv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4IVARBPROC, glVertexAttrib4iv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4BVARBPROC, glVertexAttrib4bv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4USVARBPROC, glVertexAttrib4usv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4UBVARBPROC, glVertexAttrib4ubv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4UIVARBPROC, glVertexAttrib4uiv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4NBVARBPROC, glVertexAttrib4Nbv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4NSVARBPROC, glVertexAttrib4Nsv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4NIVARBPROC, glVertexAttrib4Niv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4NUBVARBPROC, glVertexAttrib4Nubv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4NUSVARBPROC, glVertexAttrib4Nusv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIB4NUIVARBPROC, glVertexAttrib4Nuiv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLVERTEXATTRIBPOINTERARBPROC, glVertexAttribPointer, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLENABLEVERTEXATTRIBARRAYARBPROC, glEnableVertexAttribArray, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLDISABLEVERTEXATTRIBARRAYARBPROC, glDisableVertexAttribArray, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETVERTEXATTRIBDVARBPROC, glGetVertexAttribdv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETVERTEXATTRIBFVARBPROC, glGetVertexAttribfv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETVERTEXATTRIBIVARBPROC, glGetVertexAttribiv, glShadingLanguageSupport);
SAFE_GET_PROC_ARB( PFNGLGETVERTEXATTRIBPOINTERVARBPROC, glGetVertexAttribPointerv, glShadingLanguageSupport);
}
else {
//no vertex shader support
glShadingLanguageSupport = false;
}
if ( extensionSupported( extensions, "GL_ARB_fragment_shader") ) {
//nothing presently
}
else {
//no fragment shader support
glShadingLanguageSupport = false;
}
}
if ( extensionSupported( extensions, "GL_ARB_vertex_program") && extensionSupported( extensions, "GL_ARB_fragment_program")) {
glAsmProgramSupport = true;
SAFE_GET_PROC( PFNGLPROGRAMSTRINGARBPROC, glProgramStringARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLBINDPROGRAMARBPROC, glBindProgramARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLDELETEPROGRAMSARBPROC, glDeleteProgramsARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLGENPROGRAMSARBPROC, glGenProgramsARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLPROGRAMENVPARAMETER4DARBPROC, glProgramEnvParameter4dARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLPROGRAMENVPARAMETER4DVARBPROC, glProgramEnvParameter4dvARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLPROGRAMENVPARAMETER4FARBPROC, glProgramEnvParameter4fARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLPROGRAMENVPARAMETER4FVARBPROC, glProgramEnvParameter4fvARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLPROGRAMLOCALPARAMETER4DARBPROC, glProgramLocalParameter4dARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLPROGRAMLOCALPARAMETER4DVARBPROC, glProgramLocalParameter4dvARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLPROGRAMLOCALPARAMETER4FARBPROC, glProgramLocalParameter4fARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLPROGRAMLOCALPARAMETER4FVARBPROC, glProgramLocalParameter4fvARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLGETPROGRAMENVPARAMETERDVARBPROC, glGetProgramEnvParameterdvARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLGETPROGRAMENVPARAMETERFVARBPROC, glGetProgramEnvParameterfvARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC, glGetProgramLocalParameterdvARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC, glGetProgramLocalParameterfvARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLGETPROGRAMIVARBPROC, glGetProgramivARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLGETPROGRAMSTRINGARBPROC, glGetProgramStringARB, glAsmProgramSupport);
SAFE_GET_PROC( PFNGLISPROGRAMARBPROC, glIsProgramARB, glAsmProgramSupport);
}
else {
glAsmProgramSupport = false;
}
if ( ver >= 130) {
glTexture3DSupport = true;
glMultiTextureSupport = true;
#ifdef WIN32
SAFE_GET_PROC( PFNGLACTIVETEXTUREPROC, glActiveTexture, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLCLIENTACTIVETEXTUREPROC, glClientActiveTexture, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1DPROC, glMultiTexCoord1d, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1DVPROC, glMultiTexCoord1dv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1FPROC, glMultiTexCoord1f, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1FVPROC, glMultiTexCoord1fv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1IPROC, glMultiTexCoord1i, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1IVPROC, glMultiTexCoord1iv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1SPROC, glMultiTexCoord1s, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD1SVPROC, glMultiTexCoord1sv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2DPROC, glMultiTexCoord2d, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2DVPROC, glMultiTexCoord2dv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2FPROC, glMultiTexCoord2f, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2FVPROC, glMultiTexCoord2fv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2IPROC, glMultiTexCoord2i, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2IVPROC, glMultiTexCoord2iv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2SPROC, glMultiTexCoord2s, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD2SVPROC, glMultiTexCoord2sv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3DPROC, glMultiTexCoord3d, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3DVPROC, glMultiTexCoord3dv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3FPROC, glMultiTexCoord3f, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3FVPROC, glMultiTexCoord3fv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3IPROC, glMultiTexCoord3i, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3IVPROC, glMultiTexCoord3iv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3SPROC, glMultiTexCoord3s, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD3SVPROC, glMultiTexCoord3sv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4DPROC, glMultiTexCoord4d, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4DVPROC, glMultiTexCoord4dv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4FPROC, glMultiTexCoord4f, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4FVPROC, glMultiTexCoord4fv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4IPROC, glMultiTexCoord4i, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4IVPROC, glMultiTexCoord4iv, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4SPROC, glMultiTexCoord4s, glMultiTextureSupport);
SAFE_GET_PROC( PFNGLMULTITEXCOORD4SVPROC, glMultiTexCoord4sv, glMultiTextureSupport);
#endif
#ifdef WIN32
SAFE_GET_PROC( PFNGLTEXIMAGE3DEXTPROC, glTexImage3D, glTexture3DSupport);
SAFE_GET_PROC( PFNGLTEXSUBIMAGE3DPROC, glTexSubImage3D, glTexture3DSupport);
SAFE_GET_PROC( PFNGLCOPYTEXSUBIMAGE3DPROC, glCopyTexSubImage3D, glTexture3DSupport);
#endif
}
else {
if (extensionSupported( extensions, "GL_ARB_multitexture")) {
glMultiTextureSupport = true;
#ifdef WIN32
SAFE_GET_PROC_ARB( PFNGLACTIVETEXTUREPROC, glActiveTexture, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLCLIENTACTIVETEXTUREPROC, glClientActiveTexture, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD1DPROC, glMultiTexCoord1d, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD1DVPROC, glMultiTexCoord1dv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD1FPROC, glMultiTexCoord1f, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD1FVPROC, glMultiTexCoord1fv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD1IPROC, glMultiTexCoord1i, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD1IVPROC, glMultiTexCoord1iv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD1SPROC, glMultiTexCoord1s, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD1SVPROC, glMultiTexCoord1sv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD2DPROC, glMultiTexCoord2d, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD2DVPROC, glMultiTexCoord2dv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD2FPROC, glMultiTexCoord2f, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD2FVPROC, glMultiTexCoord2fv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD2IPROC, glMultiTexCoord2i, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD2IVPROC, glMultiTexCoord2iv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD2SPROC, glMultiTexCoord2s, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD2SVPROC, glMultiTexCoord2sv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD3DPROC, glMultiTexCoord3d, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD3DVPROC, glMultiTexCoord3dv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD3FPROC, glMultiTexCoord3f, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD3FVPROC, glMultiTexCoord3fv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD3IPROC, glMultiTexCoord3i, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD3IVPROC, glMultiTexCoord3iv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD3SPROC, glMultiTexCoord3s, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD3SVPROC, glMultiTexCoord3sv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD4DPROC, glMultiTexCoord4d, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD4DVPROC, glMultiTexCoord4dv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD4FPROC, glMultiTexCoord4f, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD4FVPROC, glMultiTexCoord4fv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD4IPROC, glMultiTexCoord4i, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD4IVPROC, glMultiTexCoord4iv, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD4SPROC, glMultiTexCoord4s, glMultiTextureSupport);
SAFE_GET_PROC_ARB( PFNGLMULTITEXCOORD4SVPROC, glMultiTexCoord4sv, glMultiTextureSupport);
#endif
}
if (extensionSupported( extensions, "GL_EXT_texture3D")) {
glTexture3DSupport = true;
#ifdef WIN32
SAFE_GET_PROC_EXT( PFNGLTEXIMAGE3DEXTPROC, glTexImage3D, glTexture3DSupport);
SAFE_GET_PROC_EXT( PFNGLTEXSUBIMAGE3DPROC, glTexSubImage3D, glTexture3DSupport);
SAFE_GET_PROC_EXT( PFNGLCOPYTEXSUBIMAGE3DPROC, glCopyTexSubImage3D, glTexture3DSupport);
#endif
}
}
//search for point parameters and Blend Equation
if ( ver >= 140) {
glPointParametersSupport = true;
glBlendEquationSupport = true;
#ifndef WIN32
// Comment out temporarily to avoid crash on Linux.
glSecondaryColorSupport = false;
#endif
SAFE_GET_PROC( PFNGLPOINTPARAMETERFPROC, glPointParameterf, glPointParametersSupport);
SAFE_GET_PROC( PFNGLPOINTPARAMETERFVPROC, glPointParameterfv, glPointParametersSupport);
#ifdef WIN32
SAFE_GET_PROC( PFNGLBLENDEQUATIONPROC, glBlendEquation, glBlendEquationSupport);
#endif
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3BPROC, glSecondaryColor3b, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3BVPROC, glSecondaryColor3bv, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3DPROC, glSecondaryColor3d, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3DVPROC, glSecondaryColor3dv, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3FPROC, glSecondaryColor3f, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3FVPROC, glSecondaryColor3fv, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3IPROC, glSecondaryColor3i, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3IVPROC, glSecondaryColor3iv, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3SPROC, glSecondaryColor3s, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3SVPROC, glSecondaryColor3sv, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3UBPROC, glSecondaryColor3ub, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3UBVPROC, glSecondaryColor3ubv, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3UIPROC, glSecondaryColor3ui, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3UIVPROC, glSecondaryColor3uiv, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3USPROC, glSecondaryColor3us, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLOR3USVPROC, glSecondaryColor3usv, glSecondaryColorSupport);
SAFE_GET_PROC( PFNGLSECONDARYCOLORPOINTERPROC, glSecondaryColorPointer, glSecondaryColorSupport);
}
// This should be set based on the existence of > version 1.4, but
// for now explicitly check for the extension as there are some issues
// with ATI drivers emulating mipmaps of NPOTS in software.
if (extensionSupported(extensions, "GL_ARB_texture_non_power_of_two"))
{
glTextureNonPowerOfTwo = true;
}
}
extensionsAvailable = glShadingLanguageSupport && glMultiTextureSupport && glAsmProgramSupport && glTexture3DSupport;
return extensionsAvailable;
}
void
OSGLContext_x11::initGLXData(OSGLContext_glx_data* glxInfo)
{
//Sets all bits to 0
memset( glxInfo->_imp.get(), 0, sizeof(OSGLContext_glx_dataPrivate) );
XInitThreads();
glxInfo->_imp->x11.display = XOpenDisplay(NULL);
if (!glxInfo->_imp->x11.display) {
throw std::runtime_error("X11: Failed to open display");
}
glxInfo->_imp->x11.screen = DefaultScreen(glxInfo->_imp->x11.display);
glxInfo->_imp->x11.root = RootWindow(glxInfo->_imp->x11.display, glxInfo->_imp->x11.screen);
glxInfo->_imp->x11.context = XUniqueContext();
const char* sonames[] =
{
#if defined(__CYGWIN__)
"libGL-1.so",
#else
"libGL.so.1",
"libGL.so",
#endif
NULL
};
for (int i = 0; sonames[i]; ++i) {
glxInfo->_imp->handle = dlopen(sonames[i], RTLD_LAZY | RTLD_GLOBAL);
if (glxInfo->_imp->handle) {
break;
}
}
if (!glxInfo->_imp->handle) {
throw std::runtime_error("GLX: Failed to load GLX");
}
glxInfo->_imp->GetFBConfigs = (PFNGLXGETFBCONFIGSPROC)dlsym(glxInfo->_imp->handle, "glXGetFBConfigs");
glxInfo->_imp->GetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)dlsym(glxInfo->_imp->handle, "glXGetFBConfigAttrib");
glxInfo->_imp->GetClientString = (PFNGLXGETCLIENTSTRINGPROC)dlsym(glxInfo->_imp->handle, "glXGetClientString");
glxInfo->_imp->QueryExtension = (PFNGLXQUERYEXTENSIONPROC)dlsym(glxInfo->_imp->handle, "glXQueryExtension");
glxInfo->_imp->QueryVersion = (PFNGLXQUERYVERSIONPROC)dlsym(glxInfo->_imp->handle, "glXQueryVersion");
glxInfo->_imp->DestroyContext = (PFNGLXDESTROYCONTEXTPROC)dlsym(glxInfo->_imp->handle, "glXDestroyContext");
glxInfo->_imp->MakeCurrent = (PFNGLXMAKECURRENTPROC)dlsym(glxInfo->_imp->handle, "glXMakeCurrent");
glxInfo->_imp->SwapBuffers = (PFNGLXSWAPBUFFERSPROC)dlsym(glxInfo->_imp->handle, "glXSwapBuffers");
glxInfo->_imp->QueryExtensionsString = (PFNGLXQUERYEXTENSIONSSTRINGPROC)dlsym(glxInfo->_imp->handle, "glXQueryExtensionsString");
glxInfo->_imp->CreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)dlsym(glxInfo->_imp->handle, "glXCreateNewContext");
glxInfo->_imp->CreateWindow = (PFNGLXCREATEWINDOWPROC)dlsym(glxInfo->_imp->handle, "glXCreateWindow");
glxInfo->_imp->DestroyWindow = (PFNGLXDESTROYWINDOWPROC)dlsym(glxInfo->_imp->handle, "glXDestroyWindow");
glxInfo->_imp->GetProcAddress = (PFNGLXGETPROCADDRESSPROC)dlsym(glxInfo->_imp->handle, "glXGetProcAddress");
glxInfo->_imp->GetProcAddressARB = (PFNGLXGETPROCADDRESSPROC)dlsym(glxInfo->_imp->handle, "glXGetProcAddressARB");
glxInfo->_imp->GetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)dlsym(glxInfo->_imp->handle, "glXGetVisualFromFBConfig");
glxInfo->_imp->MakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)dlsym(glxInfo->_imp->handle, "glXMakeContextCurrent");
glxInfo->_imp->IsDirect = (PFNGLXISDIRECT)dlsym(glxInfo->_imp->handle, "glXIsDirect");
if ( !glxInfo->_imp->QueryExtension(glxInfo->_imp->x11.display, &glxInfo->_imp->errorBase, &glxInfo->_imp->eventBase) ) {
throw std::runtime_error("GLX: GLX extension not found");
}
if ( !glxInfo->_imp->QueryVersion(glxInfo->_imp->x11.display, &glxInfo->_imp->major, &glxInfo->_imp->minor) ) {
throw std::runtime_error("GLX: Failed to query GLX version");
}
if ( (glxInfo->_imp->major == 1) && (glxInfo->_imp->minor < 3) ) {
throw std::runtime_error("GLX: GLX version 1.3 is required");
}
if ( extensionSupported(glxInfo, "GLX_EXT_swap_control") ) {
glxInfo->_imp->SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)getProcAddress(glxInfo, "glXSwapIntervalEXT");
if (glxInfo->_imp->SwapIntervalEXT) {
glxInfo->_imp->EXT_swap_control = GL_TRUE;
}
}
if ( extensionSupported(glxInfo, "GLX_SGI_swap_control") ) {
glxInfo->_imp->SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)getProcAddress(glxInfo, "glXSwapIntervalSGI");
if (glxInfo->_imp->SwapIntervalSGI) {
glxInfo->_imp->SGI_swap_control = GL_TRUE;
}
}
if ( extensionSupported(glxInfo, "GLX_MESA_swap_control") ) {
glxInfo->_imp->SwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)getProcAddress(glxInfo, "glXSwapIntervalMESA");
if (glxInfo->_imp->SwapIntervalMESA) {
glxInfo->_imp->MESA_swap_control = GL_TRUE;
}
}
if ( extensionSupported(glxInfo, "GLX_MESA_query_renderer") ) {
glxInfo->_imp->QueryRendererIntegerMESA = (PFNGLXQUERYRENDERERINTEGERMESA)getProcAddress(glxInfo, "glXQueryRendererIntegerMESA");
glxInfo->_imp->QueryCurrentRendererIntegerMESA = (PFNGLXQUERYCURRENTRENDERERINTEGERMESA)getProcAddress(glxInfo, "glXQueryCurrentRendererIntegerMESA");
glxInfo->_imp->QueryRendererStringMesa = (PFNGLXQUERYRENDERERSTRINGMESA)getProcAddress(glxInfo, "glXQueryRendererStringMESA");
glxInfo->_imp->QueryCurrentRendererStringMesa = (PFNGLXQUERYCURRENTRENDERERSTRINGMESA)getProcAddress(glxInfo, "glXQueryCurrentRendererStringMESA");
if (glxInfo->_imp->QueryRendererIntegerMESA) {
glxInfo->_imp->MESA_query_renderer = GL_TRUE;
}
}
if ( extensionSupported(glxInfo, "GLX_ARB_multisample") ) {
glxInfo->_imp->ARB_multisample = GL_TRUE;
}
if ( extensionSupported(glxInfo, "GLX_ARB_framebuffer_sRGB") ) {
glxInfo->_imp->ARB_framebuffer_sRGB = GL_TRUE;
}
if ( extensionSupported(glxInfo, "GLX_EXT_framebuffer_sRGB") ) {
glxInfo->_imp->EXT_framebuffer_sRGB = GL_TRUE;
}
if ( extensionSupported(glxInfo, "GLX_ARB_create_context") ) {
glxInfo->_imp->CreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)getProcAddress(glxInfo, "glXCreateContextAttribsARB");
if (glxInfo->_imp->CreateContextAttribsARB) {
glxInfo->_imp->ARB_create_context = GL_TRUE;
}
}
if ( extensionSupported(glxInfo, "GLX_ARB_create_context_robustness") ) {
glxInfo->_imp->ARB_create_context_robustness = GL_TRUE;
}
if ( extensionSupported(glxInfo, "GLX_ARB_create_context_profile") ) {
glxInfo->_imp->ARB_create_context_profile = GL_TRUE;
}
if ( extensionSupported(glxInfo, "GLX_EXT_create_context_es2_profile") ) {
glxInfo->_imp->EXT_create_context_es2_profile = GL_TRUE;
}
if ( extensionSupported(glxInfo, "GLX_ARB_context_flush_control") ) {
glxInfo->_imp->ARB_context_flush_control = GL_TRUE;
}
} // initGLXData
bool
OSGLContext_win::loadWGLExtensions(OSGLContext_wgl_data* wglInfo)
{
// This should be protected by a mutex externally
if (wglInfo->extensionsLoaded) {
return false;
}
// Functions for WGL_EXT_extension_string
// NOTE: These are needed by extensionSupported
wglInfo->GetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)wglInfo->GetProcAddress("wglGetExtensionsStringEXT");
wglInfo->GetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)wglInfo->GetProcAddress("wglGetExtensionsStringARB");
// Functions for WGL_ARB_create_context
wglInfo->CreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)wglInfo->GetProcAddress("wglCreateContextAttribsARB");
// Functions for WGL_EXT_swap_control
wglInfo->SwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)wglInfo->GetProcAddress("wglSwapIntervalEXT");
// Functions for WGL_ARB_pixel_format
wglInfo->GetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)wglInfo->GetProcAddress("wglGetPixelFormatAttribivARB");
// This needs to include every extension used below except for
// WGL_ARB_extensions_string and WGL_EXT_extensions_string
wglInfo->ARB_multisample = extensionSupported("WGL_ARB_multisample", wglInfo);
wglInfo->ARB_framebuffer_sRGB = extensionSupported("WGL_ARB_framebuffer_sRGB", wglInfo);
wglInfo->EXT_framebuffer_sRGB = extensionSupported("WGL_EXT_framebuffer_sRGB", wglInfo);
wglInfo->ARB_create_context = extensionSupported("WGL_ARB_create_context", wglInfo);
wglInfo->ARB_create_context_profile = extensionSupported("WGL_ARB_create_context_profile", wglInfo);
wglInfo->EXT_create_context_es2_profile = extensionSupported("WGL_EXT_create_context_es2_profile", wglInfo);
wglInfo->ARB_create_context_robustness = extensionSupported("WGL_ARB_create_context_robustness", wglInfo);
wglInfo->EXT_swap_control = extensionSupported("WGL_EXT_swap_control", wglInfo);
wglInfo->ARB_pixel_format = extensionSupported("WGL_ARB_pixel_format", wglInfo);
wglInfo->ARB_context_flush_control = extensionSupported("WGL_ARB_context_flush_control", wglInfo);
wglInfo->NV_gpu_affinity = extensionSupported("WGL_NV_gpu_affinity", wglInfo);
wglInfo->AMD_gpu_association = extensionSupported("WGL_AMD_gpu_association", wglInfo);
if (wglInfo->NV_gpu_affinity) {
wglInfo->EnumGpusNV = (PFNWGLENUMGPUSNV)wglInfo->GetProcAddress("wglEnumGpusNV");
wglInfo->EnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNV)wglInfo->GetProcAddress("wglEnumGpuDevicesNV");
wglInfo->CreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNV)wglInfo->GetProcAddress("wglCreateAffinityDCNV");
wglInfo->EnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNV)wglInfo->GetProcAddress("wglEnumGpusFromAffinityDCNV");
wglInfo->DeleteDCNV = (PFNWGLDELETEDCNV)wglInfo->GetProcAddress("wglDeleteDCNV");
}
if (wglInfo->AMD_gpu_association) {
wglInfo->GetGpuIDAMD = (PFNWGLGETGPUIDSAMD)wglInfo->GetProcAddress("wglGetGPUIDsAMD");
wglInfo->GetGPUInfoAMD = (PFNWGLGETGPUINFOAMD)wglInfo->GetProcAddress("wglGetGPUInfoAMD");
wglInfo->GetContextGpuIDAMD = (PFNWGLGETCONTEXTGPUIDAMD)wglInfo->GetProcAddress("wglGetContextGPUIDAMD");
wglInfo->CreateAssociatedContextAMD = (PFNWGLCREATEASSOCIATEDCONTEXTAMD)wglInfo->GetProcAddress("wglCreateAssociatedContextAMD");
wglInfo->CreateAssociatedContextAttribsAMD = (PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMD)wglInfo->GetProcAddress("wglCreateAssociatedContextAttribsAMD");
wglInfo->DeleteAssociatedContextAMD = (PFNWGLDELETEASSOCIATEDCONTEXTAMD)wglInfo->GetProcAddress("wglDeleteAssociatedContextAMD");
wglInfo->MakeAssociatedContetCurrentAMD = (PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMD)wglInfo->GetProcAddress("wglMakeAssociatedContextCurrentAMD");
wglInfo->GetCurrentAssociatedContextAMD = (PFNWGLGETCURRENTASSOCIATEDCONTEXTAMD)wglInfo->GetProcAddress("wglGetCurrentAssociatedContextAMD");
wglInfo->BlitContextFrameBufferAMD = (PFNWGLBLITCONTEXTFRAMEBUFFERAMD)wglInfo->GetProcAddress("wglBlitContextFramebufferAMD");
}
wglInfo->extensionsLoaded = GL_TRUE;
return true;
} // OSGLContext_win::loadWGLExtensions
