bool
GLExtensions::init_gl_arb_fragment_shader()
{
#ifdef GL_ARB_fragment_shader
if (is_extension_supported("GL_ARB_fragment_shader") && init_gl_arb_shader_objects())
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_fragment_shader is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_fragment_shader is NOT supported by hardware!");
return false;
}
#else
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ARB_fragment_shader is not defined in glext.h!");
return false;
#endif
}
bool
GLExtensions::init_gl_ati_fragment_shader()
{
if (Config::get_var_bool("NO_GL_ATI_fragment_shader",false,true))
{
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ATI_fragment_shader - Just saying no!");
return false;
}
#ifdef GL_ATI_fragment_shader
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ATI_fragment_shader is defined in glext.h!");
if (is_extension_supported("GL_ATI_fragment_shader"))
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ATI_fragment_shader is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ATI_fragment_shader is NOT supported by hardware!");
return false;
}
#else //GL_ATI_fragment_shader
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ATI_fragment_shader is not defined in glext.h!");
return false;
#endif //GL_ATI_fragment_shader
}
bool
GLExtensions::init_gl_nv_fragment_program_option()
{
#ifdef GL_NV_fragment_program_option
if (is_extension_supported("GL_NV_fragment_program_option"))
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_NV_fragment_program_option is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_NV_fragment_program_option is NOT supported by hardware!");
return false;
}
#else // GL_NV_fragment_program_option
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_NV_fragment_program_option is not defined in glext.h!");
return false;
#endif // GL_NV_fragment_program_option
}
bool
GLExtensions::init_gl_arb_fragment_program()
{
if (Config::get_var_bool("NO_GL_ARB_fragment_program",false,true))
{
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ARB_fragment_program - Just saying no!");
return false;
}
#ifdef GL_ARB_fragment_program
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_fragment_program is defined in glext.h!");
if (is_extension_supported("GL_ARB_fragment_program"))
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_fragment_program is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_fragment_program is NOT supported by hardware!");
return false;
}
#else
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ARB_fragment_program is not defined in glext.h!");
return false;
#endif
}
bool
GLExtensions::init_gl_nv_register_combiners()
{
if (Config::get_var_bool("NO_GL_NV_register_combiners",false,true))
{
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_NV_register_combiners - Just saying no!");
return false;
}
#ifdef GL_NV_register_combiners
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_NV_register_combiners is defined in glext.h!");
if (is_extension_supported("GL_NV_register_combiners"))
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_NV_register_combiners is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_NV_register_combiners is NOT supported by hardware!");
return false;
}
#else //GL_NV_register_combiners
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_NV_register_combiners is not defined in glext.h!");
return false;
#endif //GL_NV_register_combiners
}
bool
GLExtensions::init_gl_arb_multitexture()
{
if (Config::get_var_bool("NO_GL_ARB_multitexture",false,true))
{
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ARB_multitexture - Just saying no!");
return false;
}
#ifdef GL_ARB_multitexture
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_multitexture is defined in glext.h!");
if (is_extension_supported("GL_ARB_multitexture"))
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_multitexture is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_multitexture is NOT supported by hardware!");
return false;
}
#else //GL_ARB_multitexture
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ARB_multitexture is not defined in glext.h!");
return false;
#endif //GL_ARB_multitexture
}
bool
GLExtensions::init_gl_ext_compiled_vertex_array()
{
if (Config::get_var_bool("NO_GL_EXT_compiled_vertex_array",false,true))
{
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_EXT_compiled_vertex_array - Just saying no!");
return false;
}
#ifdef GL_EXT_compiled_vertex_array
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_EXT_compiled_vertex_array is defined in glext.h!");
if (is_extension_supported("GL_EXT_compiled_vertex_array"))
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_EXT_compiled_vertex_array is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_EXT_compiled_vertex_array is NOT supported by hardware!");
return false;
}
#else //GL_EXT_compiled_vertex_array
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_EXT_compiled_vertex_array is not defined in glext.h!");
return false;
#endif //GL_EXT_compiled_vertex_array
}
EGLint platform_display_initialize (PlatformDisplay *display,
EGLProxyConfig **config_list)
{
const char *extensions = NULL;
display->is_modern = ((display->glx_major == 1) && (display->glx_minor > 2))
|| (display->glx_major > 1);
/* Check available GLX extensions */
extensions = glXQueryExtensionsString (display->x11_display,
display->screen);
if (is_extension_supported (extensions, "GLX_ARB_create_context")) {
display->glXCreateContextAttribsARB =
(PFNGLXCREATECONTEXTATTRIBSARBPROC)
glXGetProcAddressARB ((const GLubyte *)"glXCreateContextAttribsARB");
display->is_arb_context_profile = is_extension_supported (extensions,
"GLX_ARB_create_context_profile");
}
display->is_ext_visual_rating = is_extension_supported (
extensions,
"GLX_EXT_visual_rating");
display->is_ext_visual_info = is_extension_supported (
extensions,
"GLX_EXT_visual_info");
display->is_arb_multisample = is_extension_supported (
extensions,
"GLX_ARB_multisample");
display->is_ext_create_context_es_profile = is_extension_supported (
extensions,
"GLX_EXT_create_context_es_profile");
display->is_ext_create_context_es2_profile = is_extension_supported (
extensions,
"GLX_EXT_create_context_es2_profile");
if (display->is_modern) {
return glx_populate_from_fbconfigs (display, config_list);
}
return glx_populate_from_visualinfos (display, config_list);
}
/***********************************************************************
* wglGetProcAddress (OPENGL32.@)
*/
PROC WINAPI wglGetProcAddress(LPCSTR lpszProc) {
void *local_func;
OpenGL_extension ext;
const OpenGL_extension *ext_ret;
TRACE("(%s)\n", lpszProc);
if(lpszProc == NULL)
return NULL;
/* First, look if it's not already defined in the 'standard' OpenGL functions */
if ((local_func = GetProcAddress(opengl32_handle, lpszProc)) != NULL) {
TRACE(" found function in 'standard' OpenGL functions (%p)\n", local_func);
return local_func;
}
/* After that, search in the thunks to find the real name of the extension */
ext.name = lpszProc;
ext_ret = (const OpenGL_extension *) bsearch(&ext, extension_registry,
extension_registry_size, sizeof(OpenGL_extension), compar);
/* If nothing was found, we are looking for a WGL extension or an unknown GL extension. */
if (ext_ret == NULL) {
/* If the function name starts with a w it is a WGL extension */
if(lpszProc[0] == 'w')
return wine_wgl.p_wglGetProcAddress(lpszProc);
/* We are dealing with an unknown GL extension. */
WARN("Extension '%s' not defined in opengl32.dll's function table!\n", lpszProc);
return NULL;
} else { /* We are looking for an OpenGL extension */
/* Check if the GL extension required by the function is available */
if(!is_extension_supported(ext_ret->extension)) {
WARN("Extension '%s' required by function '%s' not supported!\n", ext_ret->extension, lpszProc);
}
local_func = wine_wgl.p_wglGetProcAddress(ext_ret->name);
/* After that, look at the extensions defined in the Linux OpenGL library */
if (local_func == NULL) {
char buf[256];
void *ret = NULL;
/* Remove the 3 last letters (EXT, ARB, ...).
I know that some extensions have more than 3 letters (MESA, NV,
INTEL, ...), but this is only a stop-gap measure to fix buggy
OpenGL drivers (moreover, it is only useful for old 1.0 apps
that query the glBindTextureEXT extension).
*/
memcpy(buf, ext_ret->name, strlen(ext_ret->name) - 3);
buf[strlen(ext_ret->name) - 3] = '\0';
TRACE(" extension not found in the Linux OpenGL library, checking against libGL bug with %s..\n", buf);
ret = GetProcAddress(opengl32_handle, buf);
if (ret != NULL) {
TRACE(" found function in main OpenGL library (%p) !\n", ret);
} else {
WARN("Did not find function %s (%s) in your OpenGL library !\n", lpszProc, ext_ret->name);
}
return ret;
} else {
TRACE(" returning function (%p)\n", ext_ret->func);
extension_funcs[ext_ret - extension_registry] = local_func;
return ext_ret->func;
}
}
}
int
main(int argc, char *argv[])
{
Display *dpy;
Window win;
GLXContext ctx;
char *dpyName = NULL;
int swap_interval = 1;
GLboolean do_swap_interval = GL_FALSE;
GLboolean force_get_rate = GL_FALSE;
GLboolean fullscreen = GL_FALSE;
GLboolean printInfo = GL_FALSE;
int i;
PFNGLXSWAPINTERVALMESAPROC set_swap_interval = NULL;
PFNGLXGETSWAPINTERVALMESAPROC get_swap_interval = NULL;
int width = 300, height = 300;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-display") == 0 && i + 1 < argc) {
dpyName = argv[i+1];
i++;
}
else if (strcmp(argv[i], "-info") == 0) {
printInfo = GL_TRUE;
}
else if (strcmp(argv[i], "-swap") == 0 && i + 1 < argc) {
swap_interval = atoi( argv[i+1] );
do_swap_interval = GL_TRUE;
i++;
}
else if (strcmp(argv[i], "-forcegetrate") == 0) {
/* This option was put in because some DRI drivers don't support the
* full GLX_OML_sync_control extension, but they do support
* glXGetMscRateOML.
*/
force_get_rate = GL_TRUE;
}
else if (strcmp(argv[i], "-fullscreen") == 0) {
fullscreen = GL_TRUE;
}
else if (strcmp(argv[i], "-ztrick") == 0) {
use_ztrick = GL_TRUE;
}
else if (strcmp(argv[i], "-help") == 0) {
printf("Usage:\n");
printf(" gears [options]\n");
printf("Options:\n");
printf(" -help Print this information\n");
printf(" -display displayName Specify X display\n");
printf(" -info Display GL information\n");
printf(" -swap N Swap no more than once per N vertical refreshes\n");
printf(" -forcegetrate Try to use glXGetMscRateOML function\n");
printf(" -fullscreen Full-screen window\n");
return 0;
}
}
dpy = XOpenDisplay(dpyName);
if (!dpy) {
printf("Error: couldn't open display %s\n", XDisplayName(dpyName));
return -1;
}
make_window(dpy, "glxgears", 0, 0, width, height, fullscreen, &win, &ctx);
XMapWindow(dpy, win);
glXMakeCurrent(dpy, win, ctx);
make_extension_table( (char *) glXQueryExtensionsString(dpy,DefaultScreen(dpy)) );
has_OML_sync_control = is_extension_supported( "GLX_OML_sync_control" );
has_SGI_swap_control = is_extension_supported( "GLX_SGI_swap_control" );
has_MESA_swap_control = is_extension_supported( "GLX_MESA_swap_control" );
has_MESA_swap_frame_usage = is_extension_supported( "GLX_MESA_swap_frame_usage" );
if ( has_MESA_swap_control ) {
set_swap_interval = (PFNGLXSWAPINTERVALMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXSwapIntervalMESA" );
get_swap_interval = (PFNGLXGETSWAPINTERVALMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXGetSwapIntervalMESA" );
}
else if ( has_SGI_swap_control ) {
set_swap_interval = (PFNGLXSWAPINTERVALMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXSwapIntervalSGI" );
}
if ( has_MESA_swap_frame_usage ) {
get_frame_usage = (PFNGLXGETFRAMEUSAGEMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXGetFrameUsageMESA" );
}
if (printInfo) {
printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
if ( has_OML_sync_control || force_get_rate ) {
show_refresh_rate( dpy );
}
if ( get_swap_interval != NULL ) {
printf("Default swap interval = %d\n", (*get_swap_interval)() );
}
}
if ( do_swap_interval ) {
if ( set_swap_interval != NULL ) {
if ( ((swap_interval == 0) && !has_MESA_swap_control)
|| (swap_interval < 0) ) {
printf( "Swap interval must be non-negative or greater than zero "
"if GLX_MESA_swap_control is not supported.\n" );
}
else {
(*set_swap_interval)( swap_interval );
}
if ( printInfo && (get_swap_interval != NULL) ) {
printf("Current swap interval = %d\n", (*get_swap_interval)() );
}
}
else {
printf("Unable to set swap-interval. Neither GLX_SGI_swap_control "
"nor GLX_MESA_swap_control are supported.\n" );
}
}
init();
/* Set initial projection/viewing transformation.
* same as glxgears.c
*/
reshape(width, height);
event_loop(dpy, win);
glXDestroyContext(dpy, ctx);
XDestroyWindow(dpy, win);
XCloseDisplay(dpy);
return 0;
}
