/**
* gdk_gl_query_version:
* @major: returns the major version number of the OpenGL extension.
* @minor: returns the minor version number of the OpenGL extension.
*
* Returns the version numbers of the OpenGL extension to the window system.
*
* In the X Window System, it returns the GLX version.
*
* In the Microsoft Windows, it returns the Windows version.
*
* Return value: FALSE if it fails, TRUE otherwise.
**/
gboolean
gdk_gl_query_version (int *major,
int *minor)
{
#ifdef GDKGLEXT_MULTIHEAD_SUPPORT
return glXQueryVersion (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
major, minor);
#else /* GDKGLEXT_MULTIHEAD_SUPPORT */
return glXQueryVersion (gdk_x11_get_default_xdisplay (),
major, minor);
#endif /* GDKGLEXT_MULTIHEAD_SUPPORT */
}
int x11_opengl_pixel_format( unsigned int * attribs )
{
int attrib[] = {GLX_RGBA, GLX_DOUBLEBUFFER, // need double buffering
GLX_RGBA,
GLX_DEPTH_SIZE, 16, // put in the depth size
// that was passed to us
GLX_RED_SIZE, 8, // 8 bits pretty standard for our RGBA
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE,8,
GLX_ALPHA_SIZE, 8,
None };
int glx_major, glx_minor;
if ( !glXQueryVersion( x11_current_display(), &glx_major, &glx_minor ) ||
(glx_major == 1) && (glx_minor < 3) || (glx_major < 1) )
{
xwl_set_error( "Invalid GLX version!" );
return 0;
}
XVisualInfo * visual = glXChooseVisual( x11_current_display(), x11_current_screen(), attrib );
return visual->visualid;
} // x11_opengl_pixel_format
/*****************************************************************
This function try find if extension is supported by GLX.
Parameters:
===========
Display *dpy - handle to a window.
int screen - screen in which GLX draws.
char *extension - name of extension.
Returns:
========
return 1 if extension exist
0 otherwise
******************************************************************/
int glxExtensionSupported( Display *dpy, int screen, char *extension)
{
int major, minor;
const char *extensions, *start;
char *where, *terminator;
if (glXQueryVersion(dpy, &major, &minor))
{
if (minor >= 1 || major > 1)
{
extensions = glXQueryExtensionsString(dpy, screen);
start = extensions;
while(1)
{
where = strstr(start, extension);
if (!where)
return 0;
terminator = where + strlen(extension);
if (where == start || *(where - 1) == ' ')
if (*terminator == ' ' || *terminator == '0')
return 1;
start = terminator;
}
}
}
return 0;
}
void
init(void) {
initX();
int major = 0, minor = 0;
if (!glXQueryVersion(display, &major, &minor)) {
std::cerr << "error: failed to obtain GLX version\n";
exit(1);
}
const int requiredMajor = 1, requiredMinor = 3;
if (major < requiredMajor ||
(major == requiredMajor && minor < requiredMinor)) {
std::cerr << "error: GLX version " << requiredMajor << "." << requiredMinor << " required, but got version " << major << "." << minor << "\n";
exit(1);
}
glXQueryExtension(display, &errorBase, &eventBase);
oldErrorHandler = XSetErrorHandler(errorHandler);
extensions = glXQueryExtensionsString(display, screen);
#define CHECK_EXTENSION(name) \
has_##name = checkExtension(#name, extensions)
CHECK_EXTENSION(GLX_ARB_create_context);
CHECK_EXTENSION(GLX_ARB_create_context_profile);
CHECK_EXTENSION(GLX_EXT_create_context_es_profile);
CHECK_EXTENSION(GLX_EXT_create_context_es2_profile);
#undef CHECK_EXTENSION
}
/**
* Test if we pixel buffers are available for a particular X screen.
* Input: dpy - the X display
* screen - screen number
* Return: 0 = pixel buffers not available.
* 1 = pixel buffers are available via GLX 1.3.
* 2 = pixel buffers are available via GLX_SGIX_fbconfig/pbuffer.
*/
int
QueryPbuffers(Display *dpy, int screen)
{
#if defined(GLX_VERSION_1_3)
{
/* GLX 1.3 supports pbuffers */
int glxVersionMajor, glxVersionMinor;
if (!glXQueryVersion(dpy, &glxVersionMajor, &glxVersionMinor)) {
/* GLX not available! */
return 0;
}
if (glxVersionMajor * 100 + glxVersionMinor >= 103) {
return 1;
}
/* fall-through */
}
#endif
#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
/* Try the SGIX extensions */
{
char *extensions;
extensions = (char *) glXQueryServerString(dpy, screen, GLX_EXTENSIONS);
if (!extensions ||
!strstr(extensions,"GLX_SGIX_fbconfig") ||
!strstr(extensions,"GLX_SGIX_pbuffer")) {
return 0;
}
return 2;
}
#endif
return 0;
}
PlatformDisplay *platform_display_create (const PlatformDisplayAttributes
*attributes)
{
Display *x11_display = attributes->native_display;
int glx_major = 0;
int glx_minor = 0;
if (x11_display == EGL_DEFAULT_DISPLAY) {
x11_display = XOpenDisplay ((char *)NULL);
if (x11_display == NULL) {
return NULL;
}
}
if (glXQueryVersion (x11_display, &glx_major, &glx_minor) == True) {
if ((glx_major > 1) || ((glx_major == 1) && (glx_minor >= 2))) {
PlatformDisplay *display = (PlatformDisplay *) calloc (1,
sizeof (PlatformDisplay));
if (display != NULL) {
display->x11_display = x11_display;
display->screen = attributes->screen;
display->glx_major = glx_major;
display->glx_minor = glx_minor;
return display;
}
}
}
return NULL;
}
int glx_pixmap_dummy()
{
Display *dpy;
int major;
int minor;
dpy = XOpenDisplay( NULL );
if ( dpy == NULL ) {
printf( "Unable to open a connection to the X server\n" );
return 0;
}
/*
On some systems, the GLX library will report that it is version
1.2, but some 1.3 functions will be implemented, and, furthermore,
some 1.2 functions won't work right, while the 1.3 functions will.
The 1.3 will however generate a MESA warning at runtime.
To workaround this, detect the situation and use 'hybrid' mix of
1.2 and 1.3 as needed.
*/
glXQueryVersion(dpy, &major, &minor);
if (minor<=2)
if (glXCreatePixmap!=NULL) // 1.3 function exists
return glx_1_3_pixmap_dummy(dpy,True);
else
return glx_1_2_pixmap_dummy(dpy);
else if (minor>=3)
return glx_1_3_pixmap_dummy(dpy,False);
}
jboolean queryGLX13(Display *display) {
int major, minor;
int errorBase, eventBase;
if (!glXQueryExtension(display, &errorBase, &eventBase)) {
fprintf(stderr, "ES2 Prism: Error - GLX extension is not supported\n");
fprintf(stderr, " GLX version 1.3 or higher is required\n");
return JNI_FALSE;
}
/* Query the GLX version number */
if (!glXQueryVersion(display, &major, &minor)) {
fprintf(stderr, "ES2 Prism: Error - Unable to query GLX version\n");
fprintf(stderr, " GLX version 1.3 or higher is required\n");
return JNI_FALSE;
}
/*
fprintf(stderr, "Checking GLX version : %d.%d\n", major, minor);
*/
/* Check for GLX 1.3 and higher */
if (!(major == 1 && minor >= 3)) {
fprintf(stderr, "ES2 Prism: Error - reported GLX version = %d.%d\n", major, minor);
fprintf(stderr, " GLX version 1.3 or higher is required\n");
return JNI_FALSE;
}
return JNI_TRUE;
}
void checkGlxVersion(Display* display) {
int glx_major, glx_minor;
// FBConfigs were added in GLX version 1.3.
if (!glXQueryVersion(display, &glx_major, &glx_minor) ||
((glx_major == 1) && (glx_minor < 3)) || (glx_major < 1))
fail("Invalid GLX version");
}
/**
* gdk_x11_gl_query_glx_extension:
* @glconfig: a #GdkGLConfig.
* @extension: name of GLX extension.
*
* Determines whether a given GLX extension is supported.
*
* Return value: TRUE if the GLX extension is supported, FALSE if not
* supported.
**/
gboolean
gdk_x11_gl_query_glx_extension (GdkGLConfig *glconfig,
const char *extension)
{
static const char *extensions = NULL;
const char *start;
char *where, *terminator;
int major, minor;
g_return_val_if_fail (GDK_IS_X11_GL_CONFIG (glconfig), FALSE);
/* Extension names should not have spaces. */
where = strchr (extension, ' ');
if (where || *extension == '\0')
return FALSE;
if (extensions == NULL)
{
/* Be careful not to call glXQueryExtensionsString if it
looks like the server doesn't support GLX 1.1.
Unfortunately, the original GLX 1.0 didn't have the notion
of GLX extensions. */
glXQueryVersion (GDK_GL_CONFIG_XDISPLAY (glconfig),
&major, &minor);
if ((major == 1 && minor < 1) || (major < 1))
return FALSE;
extensions = glXQueryExtensionsString (GDK_GL_CONFIG_XDISPLAY (glconfig),
GDK_GL_CONFIG_SCREEN_XNUMBER (glconfig));
}
/* It takes a bit of care to be fool-proof about parsing
the GLX extensions string. Don't be fooled by
sub-strings, etc. */
start = extensions;
for (;;)
{
where = strstr (start, extension);
if (where == NULL)
break;
terminator = where + strlen (extension);
if (where == start || *(where - 1) == ' ')
if (*terminator == ' ' || *terminator == '\0')
{
GDK_GL_NOTE (MISC, g_message (" - %s - supported", extension));
return TRUE;
}
start = terminator;
}
GDK_GL_NOTE (MISC, g_message (" - %s - not supported", extension));
return FALSE;
}
static gboolean
clutter_stage_glx_realize (ClutterStageWindow *stage_window)
{
ClutterStageX11 *stage_x11 = CLUTTER_STAGE_X11 (stage_window);
ClutterStageGLX *stage_glx = CLUTTER_STAGE_GLX (stage_window);
ClutterBackendX11 *backend_x11;
ClutterBackendGLX *backend_glx;
CLUTTER_NOTE (ACTOR, "Realizing stage '%s' [%p]",
G_OBJECT_TYPE_NAME (stage_window),
stage_window);
if (!_clutter_stage_x11_create_window (stage_x11))
return FALSE;
backend_x11 = stage_x11->backend;
backend_glx = CLUTTER_BACKEND_GLX (backend_x11);
if (stage_glx->glxwin == None)
{
int major;
int minor;
GLXFBConfig config;
/* Try and create a GLXWindow to use with extensions dependent on
* GLX versions >= 1.3 that don't accept regular X Windows as GLX
* drawables.
*/
if (glXQueryVersion (backend_x11->xdpy, &major, &minor) &&
major == 1 && minor >= 3 &&
_clutter_backend_glx_get_fbconfig (backend_glx, &config))
{
stage_glx->glxwin = glXCreateWindow (backend_x11->xdpy,
config,
stage_x11->xwin,
NULL);
}
}
#ifdef GLX_INTEL_swap_event
if (clutter_feature_available (CLUTTER_FEATURE_SWAP_EVENTS))
{
GLXDrawable drawable = stage_glx->glxwin
? stage_glx->glxwin
: stage_x11->xwin;
/* we unconditionally select this event because we rely on it to
* advance the master clock, and drive redraw/relayout, animations
* and event handling.
*/
glXSelectEvent (backend_x11->xdpy,
drawable,
GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK);
}
#endif /* GLX_INTEL_swap_event */
/* chain up to the StageX11 implementation */
return clutter_stage_window_parent_iface->realize (stage_window);
}
void glx_version(int& major, int& minor)
{
#ifdef GLLOADER_GLX
glXQueryVersion(glXGetCurrentDisplay(), &major, &minor);
#else
major = minor = 0;
#endif // GLLOADER_GLX
}
static bool gfx_ctx_init(void)
{
if (g_inited)
return false;
static const int visual_attribs[] = {
GLX_X_RENDERABLE , True,
GLX_DRAWABLE_TYPE , GLX_WINDOW_BIT,
GLX_RENDER_TYPE , GLX_RGBA_BIT,
GLX_DOUBLEBUFFER , True,
GLX_RED_SIZE , 8,
GLX_GREEN_SIZE , 8,
GLX_BLUE_SIZE , 8,
GLX_ALPHA_SIZE , 8,
GLX_DEPTH_SIZE , 0,
GLX_STENCIL_SIZE , 0,
None
};
GLXFBConfig *fbcs = NULL;
g_quit = 0;
init_lut();
g_dpy = XOpenDisplay(NULL);
if (!g_dpy)
goto error;
// GLX 1.3+ required.
int major, minor;
glXQueryVersion(g_dpy, &major, &minor);
if (major < 1 || (major == 1 && minor < 3))
goto error;
int nelements;
fbcs = glXChooseFBConfig(g_dpy, DefaultScreen(g_dpy),
visual_attribs, &nelements);
if (!fbcs)
goto error;
if (!nelements)
{
XFree(fbcs);
goto error;
}
g_fbc = fbcs[0];
XFree(fbcs);
return true;
error:
gfx_ctx_destroy();
return false;
}
gboolean
_gdk_x11_gl_query_version_for_display (GdkDisplay *display,
int *major,
int *minor)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
return glXQueryVersion (GDK_DISPLAY_XDISPLAY (display),
major, minor);
}
static int query_glx_version(ALLEGRO_SYSTEM_XGLX *system)
{
int major, minor;
int version;
glXQueryVersion(system->x11display, &major, &minor);
version = major * 100 + minor * 10;
ALLEGRO_INFO("GLX %.1f.\n", version / 100.f);
return version;
}
/*
* Class: javax_media_j3d_X11NativeScreenInfo
* Method: queryGLX13
* Signature: (J)Z
*/
JNIEXPORT jboolean JNICALL
Java_javax_media_j3d_X11NativeScreenInfo_queryGLX13(
JNIEnv *env,
jclass cls,
jlong display)
{
/* Fix for Issue 20 */
MYPFNGLXCHOOSEFBCONFIG tmpfp;
int major, minor;
int errorBase, eventBase;
Display* dpy = (Display*)display;
/* It should be cleaner to return both the major and minor to the caller. */
if (!glXQueryExtension(dpy, &errorBase, &eventBase)) {
fprintf(stderr, "Java 3D ERROR : GLX extension is not supported\n");
fprintf(stderr, " GLX version 1.3 or higher is required\n");
return JNI_FALSE;
}
/* Query the GLX version number */
if (!glXQueryVersion(dpy, &major, &minor)) {
fprintf(stderr, "Java 3D ERROR : Unable to query GLX version\n");
fprintf(stderr, " GLX version 1.3 or higher is required\n");
return JNI_FALSE;
}
/*fprintf(stderr, "Checking GLX version : %d.%d\n", major, minor);*/
tmpfp = (MYPFNGLXCHOOSEFBCONFIG)dlsym(RTLD_DEFAULT, "glXChooseFBConfig");
if (tmpfp == NULL) {
fprintf(stderr, "Java 3D ERROR : glXChooseFBConfig not found\n");
fprintf(stderr, " GLX version = %d.%d\n", major, minor);
fprintf(stderr, " GLX version 1.3 or higher is required\n");
return JNI_FALSE;
}
/* Check for GLX 1.3 and higher */
if (!(major == 1 && minor >= 3)) {
fprintf(stderr, "Java 3D WARNING : reported GLX version = %d.%d\n", major, minor);
fprintf(stderr, " GLX version 1.3 or higher is required\n");
fprintf(stderr,
" The reported version number may be incorrect. There is a known\n");
fprintf(stderr,
" ATI driver bug in glXQueryVersion that incorrectly reports the GLX\n");
fprintf(stderr,
" version as 1.2 when it really is 1.3, so Java 3D will attempt to\n");
fprintf(stderr,
" run anyway.\n");
/*return JNI_FALSE;*/
}
return JNI_TRUE;
}
void GSWndOGL::CheckContext()
{
int glxMajorVersion, glxMinorVersion;
glXQueryVersion(m_NativeDisplay, &glxMajorVersion, &glxMinorVersion);
if (glXIsDirect(m_NativeDisplay, m_context))
fprintf(stdout, "glX-Version %d.%d with Direct Rendering\n", glxMajorVersion, glxMinorVersion);
else {
fprintf(stderr, "glX-Version %d.%d with Indirect Rendering !!! It won't support properly opengl\n", glxMajorVersion, glxMinorVersion);
throw GSDXRecoverableError();
}
}
//TODO: DROP ???
void GSWndWGL::CheckContext()
{
#if 0
int glxMajorVersion, glxMinorVersion;
glXQueryVersion(m_NativeDisplay, &glxMajorVersion, &glxMinorVersion);
if (glXIsDirect(m_NativeDisplay, m_context))
fprintf(stderr, "glX-Version %d.%d with Direct Rendering\n", glxMajorVersion, glxMinorVersion);
else
fprintf(stderr, "glX-Version %d.%d with Indirect Rendering !!! It won't support properly opengl\n", glxMajorVersion, glxMinorVersion);
#endif
}
void GLWindow::GetGLXVersion()
{
int glxMajorVersion, glxMinorVersion;
glXQueryVersion(glDisplay, &glxMajorVersion, &glxMinorVersion);
if (glXIsDirect(glDisplay, context))
ZZLog::Error_Log("glX-Version %d.%d with Direct Rendering", glxMajorVersion, glxMinorVersion);
else
ZZLog::Error_Log("glX-Version %d.%d with Indirect Rendering !!! It will be slow", glxMajorVersion, glxMinorVersion);
}
t_ilm_bool createGLXContext(t_ilm_int width, t_ilm_int height)
{
int glxMajor;
int glxMinor;
g_glxContextStruct.glxContext = glXCreateContext( g_x11ContextStruct.x11Display, g_x11ContextStruct.x11Visual, 0, GL_TRUE);
glXMakeCurrent(g_x11ContextStruct.x11Display, g_x11ContextStruct.x11Window, g_glxContextStruct.glxContext);
// do egl stuff
glXQueryVersion(g_x11ContextStruct.x11Display, &glxMajor, &glxMinor);
printf("GLX-Version %d.%d\n", glxMajor, glxMinor);
if (glXIsDirect(g_x11ContextStruct.x11Display, g_glxContextStruct.glxContext))
{
printf("DRI enabled\n");
}
else
{
printf("no DRI available\n");
}
t_ilm_layer layerid = (t_ilm_layer) LAYER_EXAMPLE_X_APPLICATIONS; // TODO: remove all C stylec asts in C++ code
t_ilm_surface surfaceid = (t_ilm_surface) SURFACE_EXAMPLE_GLXX11_APPLICATION;
printf("create a surface %lu\n", (t_ilm_nativehandle) (g_x11ContextStruct.x11Window));
ilm_surfaceCreate((t_ilm_nativehandle) g_x11ContextStruct.x11Window, width, height, ILM_PIXELFORMAT_RGBA_8888, &surfaceid);
printf("set surface dest region\n");
ilm_surfaceSetDestinationRectangle(surfaceid, 0, 0, width, height);
printf("set surface src region\n");
ilm_surfaceSetSourceRectangle(surfaceid, 0, 0, width, height);
printf("add surface to layer\n");
ilm_layerAddSurface(layerid, surfaceid);
printf("Set surface visible\n");
ilm_surfaceSetVisibility(surfaceid, ILM_TRUE);
printf("Set surface opacity\n");
ilm_surfaceSetOpacity(surfaceid, 0.75f);
xeventInitialiaze(g_x11ContextStruct.x11Display, surfaceid, 0, 0, width, height);
printf("commit\n");
// commit will indicate error, if any command failed
ilmErrorTypes error = ilm_commitChanges();
return (error != ILM_FAILED) ? ILM_TRUE : ILM_FALSE;
}
void wxGLCanvas::QueryGLXVersion()
{
if (m_glxVersion == 0)
{
// check the GLX version
int glxMajorVer, glxMinorVer;
bool ok = glXQueryVersion(GDK_DISPLAY(), &glxMajorVer, &glxMinorVer);
wxASSERT_MSG( ok, _T("GLX version not found") );
if (!ok)
m_glxVersion = 10; // 1.0 by default
else
m_glxVersion = glxMajorVer*10 + glxMinorVer;
}
}
void WindowImplementation::initDisplay(){
if(!display) {
throw std::runtime_error("Could not open X display");
}
int versionMajor = 0;
int versionMinor = 0;
if (!glXQueryVersion(display, &versionMajor, &versionMinor)){
throw std::runtime_error("'glXQueryVersion' failed - cannot determine supported OpenGL version");
}
if ((versionMajor < 1) || (versionMajor == 1 && versionMinor < 4)){
std::cout << "Detected Version is " << versionMajor << "." << versionMinor << std::endl;
throw std::runtime_error("This version of OpenGL is not supported. Requires at least 1.4");
}
}
// Pour initialiser la partie graphie de la bibliotheque
void initialiseGfx(int argc, char **argv)
{
#ifdef __linux__
int versionMajeureOGL;
int versionMineureOGL;
Display *affichage = XOpenDisplay(NULL);
glXQueryVersion(affichage, &versionMajeureOGL, &versionMineureOGL);
// Juste pour supprimer le bogue present dans les dernieres versions
// qui pose probleme avec VirtualBox
XCloseDisplay(affichage);
#endif
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH);
}
/*****************************************************************************
* OpenDisplay: open and initialize OpenGL device
*****************************************************************************/
static int CheckGLX( vlc_object_t *p_this, vlc_bool_t *b_glx13 )
{
Display *p_display = NULL;
int i_opcode, i_evt, i_err = 0;
int i_maj, i_min = 0;
/* Open the display */
p_display = XOpenDisplay( NULL );
if( p_display == NULL )
{
msg_Err( p_this, "Cannot open display" );
return VLC_EGENERIC;
}
/* Check for GLX extension */
if( !XQueryExtension( p_display, "GLX", &i_opcode, &i_evt, &i_err ) )
{
msg_Err( p_this, "GLX extension not supported" );
XCloseDisplay( p_display );
return VLC_EGENERIC;
}
if( !glXQueryExtension( p_display, &i_err, &i_evt ) )
{
msg_Err( p_this, "glXQueryExtension failed" );
XCloseDisplay( p_display );
return VLC_EGENERIC;
}
/* Check GLX version */
if (!glXQueryVersion( p_display, &i_maj, &i_min ) )
{
msg_Err( p_this, "glXQueryVersion failed" );
XCloseDisplay( p_display );
return VLC_EGENERIC;
}
if( i_maj <= 0 || ((i_maj == 1) && (i_min < 3)) )
{
*b_glx13 = VLC_FALSE;
msg_Dbg( p_this, "Using GLX 1.2 API" );
}
else
{
*b_glx13 = VLC_TRUE;
msg_Dbg( p_this, "Using GLX 1.3 API" );
}
XCloseDisplay( p_display );
return VLC_SUCCESS;
}
BaseOSDevice::BaseOSDevice(const WindowHandle& srcWainWindowHandle, boolean fullscrean, boolean stereo)
{
_window = srcWainWindowHandle;
_externalCreatedWindow = true;
_fullscreanWindow = fullscrean;
_glxContext = 0;
Colormap colormap;
XVisualInfo *vi = getXVisualInfo(colormap, _window);
if (vi == 0)
return;
int glxMajor=0, glxMinor=0;
glXQueryVersion(_window.display, &glxMajor, &glxMinor);
logInfo << "glXQueryVersion " << glxMajor << "." << glxMinor;
_glxContext = glXCreateContext(_window.display, vi, 0, GL_TRUE);
if(!_glxContext){
logError << "glXCreateContext";
return;
}
XSetWindowAttributes windowAttributes;
windowAttributes.colormap = colormap;
windowAttributes.border_pixel = 0;
windowAttributes.override_redirect = True;
XChangeWindowAttributes(_window.display, _window.window, CWBorderPixel | CWColormap | (fullscrean ? CWOverrideRedirect : 0), &windowAttributes);
if(fullscrean)
XMoveResizeWindow(_window.display, _window.window, 0, 0, DisplayWidth(_window.display, _window.screen), DisplayHeight(_window.display, _window.screen));
//XMapRaised(_window.display, _window.window);
if(makeCurrentContext())
{
logInfo << "Initialization OpenGL with main window - OK";
if (glXIsDirect(_window.display, _glxContext))
logInfo << "DRI enabled\n";
else
logInfo << "no DRI available\n";
}
else{
logError << "Cant create valid context";
glXDestroyContext(_window.display, _glxContext);
_glxContext = 0;
}
}
JNIEXPORT jboolean JNICALL GLX_NATIVE(glXQueryVersion)
(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jintArray arg2)
{
jint *lparg1=NULL;
jint *lparg2=NULL;
jboolean rc = 0;
GLX_NATIVE_ENTER(env, that, glXQueryVersion_FUNC);
if (arg1) if ((lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL)) == NULL) goto fail;
if (arg2) if ((lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL)) == NULL) goto fail;
rc = (jboolean)glXQueryVersion(arg0, lparg1, lparg2);
fail:
if (arg2 && lparg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
if (arg1 && lparg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
GLX_NATIVE_EXIT(env, that, glXQueryVersion_FUNC);
return rc;
}
BaseOSDevice::BaseOSDevice(const DisplayHandle& display)
{
_window.display = display.display;
_window.screen = display.screen;
_externalCreatedWindow = false;
_fullscreanWindow = false;
_glxContext = 0;
Colormap colormap;
XVisualInfo *vi = getXVisualInfo(colormap, display);
if (vi == 0)
return;
int glxMajor=0, glxMinor=0;
glXQueryVersion(_window.display, &glxMajor, &glxMinor);
logInfo << "glXQueryVersion " << glxMajor << "." << glxMinor;
_glxContext = glXCreateContext(_window.display, vi, 0, GL_TRUE);
if(!_glxContext){
logError << "glXCreateContext";
return;
}
XSetWindowAttributes windowAttributes;
windowAttributes.colormap = colormap;
windowAttributes.border_pixel = 0;
_window.window = XCreateWindow(_window.display, RootWindow(_window.display, vi->screen),
0, 0, 32, 32, 0, vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap, &windowAttributes);
if(!_window.window){
logError << "Cant create internal main window";
return;
}
XSelectInput(_window.display, _window.window, 0);
//XMapRaised(_window.display, _window.window);
if(makeCurrentContext())
logInfo << "Initialization OpenGL with internal window - OK";
else{
logError << "Cant create valid context";
glXDestroyContext(_window.display, _glxContext);
_glxContext = 0;
}
}
int main(int argc, char *argv[]) {
Display *dpy;
int eventbase, errorbase;
int major, minor;
GLXFBConfig *configs;
int numconfigs, i;
dpy = XOpenDisplay(NULL);
if(NULL == dpy) {
fprintf(stderr, "error: unable to open display!\n");
return EXIT_FAILURE;
}
if(!glXQueryExtension(dpy, &eventbase, &errorbase)) {
fprintf(stderr, "GLX is not available!\n");
return EXIT_FAILURE;
}
printf("GLX eventbase %d errorbase %d\n", eventbase, errorbase);
if(!glXQueryVersion(dpy, &major, &minor)) {
fprintf(stderr, "GLX version query error!\n");
return EXIT_FAILURE;
}
printf("GLX version: %d.%d\n", major, minor);
configs = glXGetFBConfigs(dpy, DefaultScreen(dpy), &numconfigs);
if(NULL == configs) {
fprintf(stderr, "error: retrieving GLXFBConfigs!\n");
return EXIT_FAILURE;
}
for(i = 0; i < numconfigs; ++i) {
int value;
if(Success != glXGetFBConfigAttrib(dpy, configs[i], GLX_STEREO, &value)) {
fprintf(stderr, "unable to query GLX_STEREO!\n");
return EXIT_FAILURE;
}
printf("GLXFBConfig[%d] has stereo %d\n", i, value);
}
return EXIT_SUCCESS;
}
WindowSystem::WindowSystem(Options& o) {
// If running in "compare" mode we never actually use the window
// system, so we don't initialize it here. This allows us to run
// on systems without graphics hardware/software.
if (o.mode == Options::compare) {
dpy = 0;
GLXVersMajor = GLXVersMinor = 0;
vip = 0;
return;
}
// Open the X11 display:
dpy = XOpenDisplay(o.dpyName.c_str());
if (!dpy)
throw CantOpenDisplay();
// Verify that GLX is supported:
int error_base, event_base;
if (glXQueryExtension(dpy, &error_base, &event_base) == False)
throw NoOpenGL();
// Record version numbers for later use:
if (glXQueryVersion(dpy, &GLXVersMajor, &GLXVersMinor) == False)
throw Error(); // this should never happen :-)
// Get the list of raw XVisualInfo structures:
XVisualInfo vit;
vit.screen = DefaultScreen(dpy);
int n;
vip = XGetVisualInfo(dpy, VisualScreenMask, &vit, &n);
// Construct a vector of DrawingSurfaceConfigs corresponding to the
// XVisualInfo structures that indicate they support OpenGL:
vector<DrawingSurfaceConfig*> glxv;
for (int i = 0; i < n; ++i) {
int supportsOpenGL;
glXGetConfig(dpy, &vip[i], GLX_USE_GL, &supportsOpenGL);
if (supportsOpenGL)
glxv.push_back(new DrawingSurfaceConfig (dpy, &vip[i]));
}
// Filter the basic list of DrawingSurfaceConfigs according to
// constraints provided by the user. (This makes it convenient
// to run tests on just a subset of all available configs.)
DrawingSurfaceFilter f(o.visFilter); // may throw an exception!
surfConfigs = f.filter(glxv, o.maxVisuals);
} // WindowSystem::WindowSystem
void
piglit_require_glx_version(Display *dpy, int major, int minor)
{
int glxMajor;
int glxMinor;
if (! glXQueryVersion(dpy, & glxMajor, & glxMinor)) {
fprintf(stderr, "Could not query GLX version!\n");
piglit_report_result(PIGLIT_FAIL);
}
if (glxMajor != major || glxMinor < minor) {
fprintf(stderr, "Test requires GLX %d.%d. Got %d.%d.\n",
major, minor, glxMajor, glxMinor);
piglit_report_result(PIGLIT_SKIP);
}
}
