static int
GLXExtensionSupported(Display *dpy, const char *extension)
{
const char *s;
s = glXQueryExtensionsString(dpy, DefaultScreen(dpy));
if(s != NULL && check_ext_string(s, extension))
return 1;
s = glXGetClientString(dpy, GLX_EXTENSIONS);
if(s != NULL && check_ext_string(s, extension))
return 1;
return 0;
}
static int queryClient(Display *dpy, int screen)
{
#ifdef GLX_MESA_allocate_memory
char *extensions;
extensions = (char *)glXQueryExtensionsString(dpy, screen);
if (!extensions || !strstr(extensions,"GLX_MESA_allocate_memory")) {
return 0;
}
return 1;
#else
return 0;
#endif
}
/**
* Determine whether or not a GLX extension is supported.
*/
static int
is_glx_extension_supported(Display *dpy, const char *query)
{
const int scrnum = DefaultScreen(dpy);
const char *glx_extensions = NULL;
const size_t len = strlen(query);
const char *ptr;
if (glx_extensions == NULL) {
glx_extensions = glXQueryExtensionsString(dpy, scrnum);
}
ptr = strstr(glx_extensions, query);
return ((ptr != NULL) && ((ptr[len] == ' ') || (ptr[len] == '\0')));
}
int _glfwPlatformExtensionSupported(const char* extension)
{
const GLubyte* extensions;
// Get list of GLX extensions
extensions = (const GLubyte*) glXQueryExtensionsString(_glfw.x11.display,
_glfw.x11.screen);
if (extensions != NULL)
{
if (_glfwStringInExtensionString(extension, extensions))
return GL_TRUE;
}
return GL_FALSE;
}
void investigate_swapcontrol_support() {
if (has_checked_extensions) return; // Already calculated, no need to calculate it more.
// TODO: The second argument to glXQueryExtensionsString is screen number,
// and it is unknown if the value 0 is generally correct for calling that function.
// For more information, see the following pages:
// http://pic.dhe.ibm.com/infocenter/aix/v6r1/index.jsp?topic=%2Fcom.ibm.aix.opengl%2Fdoc%2Fopenglrf%2FglXQueryExtensionsString.htm
const char *glx_extensions = glXQueryExtensionsString(enigma::x11::disp, 0);
ext_swapcontrol_supported = strstr(glx_extensions, "GLX_EXT_swap_control");
mesa_swapcontrol_supported = strstr(glx_extensions, "GLX_MESA_swap_control");
has_checked_extensions = true;
}
static bool gfx_ctx_x_bind_api(void *data, enum gfx_ctx_api api,
unsigned major, unsigned minor)
{
(void)data;
g_major = major;
g_minor = minor;
x_api = api;
switch (api)
{
case GFX_CTX_OPENGL_API:
#ifdef HAVE_OPENGL
return true;
#else
break;
#endif
case GFX_CTX_OPENGL_ES_API:
#ifdef HAVE_OPENGLES2
{
Display *dpy = XOpenDisplay(NULL);
const char *exts = glXQueryExtensionsString(dpy, DefaultScreen(dpy));
bool ret = exts && strstr(exts,
"GLX_EXT_create_context_es2_profile");
XCloseDisplay(dpy);
if (ret && g_major < 3)
{
g_major = 2; /* ES 2.0. */
g_minor = 0;
}
return ret;
}
#else
break;
#endif
case GFX_CTX_VULKAN_API:
#ifdef HAVE_VULKAN
return true;
#else
break;
#endif
case GFX_CTX_NONE:
default:
break;
}
return false;
}
bool GLXGraphicsystem::init(Display* x11Display, Window x11Window)
{
LOG_DEBUG("GLXGraphicsystem", "init");
m_x11display = x11Display;
m_window = x11Window;
if (!m_x11display)
{
LOG_ERROR("GLXGraphicsystem", "given display is null");
return false;
}
if (!m_window)
{
LOG_ERROR("GLXGraphicsystem", "given windowid is 0");
return false;
}
XVisualInfo* windowVis = GetMatchingVisual(m_x11display);
LOG_DEBUG("GLXGraphicsystem", "Initialising opengl");
m_context = glXCreateContext(m_x11display, windowVis, 0, GL_TRUE);
if (!m_context)
{
LOG_ERROR("GLXGraphicsystem", "Couldn't create GLX context!");
return false;
}
LOG_DEBUG("GLXGraphicsystem", "Make GLX Context current");
glXMakeCurrent(m_x11display, m_window, m_context);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0.0, 0.0, 0.0, 1.0);
glEnable(GL_TEXTURE_2D);
glMatrixMode(GL_MODELVIEW);
const char *ext;
ext = glXQueryExtensionsString(m_x11display, 0);
if (!strstr(ext, "GLX_EXT_texture_from_pixmap") )
{
m_zerocopy = false;
}
else
{
m_zerocopy = true;
}
LOG_DEBUG("GLXGraphicsystem", "Initialised");
return true;
}
static bool CheckGLXext (Display *dpy, unsigned snum, const char *ext)
{
const char *exts = glXQueryExtensionsString (dpy, snum);
const size_t extlen = strlen (ext);
while (*exts)
{
exts += strspn (exts, " ");
size_t len = strcspn (exts, " ");
if (len == extlen && !memcmp (exts, ext, extlen))
return true;
exts += len;
}
return false;
}
const char * getPlatformExtensions ()
{
initExtensions (); // since we will need it for platform-specific extensions
#ifdef _WIN32 // check Windoze extensions
if ( wglGetExtensionsStringARB == NULL )
return "";
return wglGetExtensionsStringARB ( wglGetCurrentDC () );
#else // check GLX extensions
Display * display = glXGetCurrentDisplay ();
int screen = DefaultScreen ( display );
return glXQueryExtensionsString ( display, screen );
#endif
}
GLboolean FWindow::Linux_InitializeGL()
{
if(!Context)
{
Context = glXCreateContext(
WindowManager::GetDisplay(),
VisualInfo, 0, GL_TRUE);
if(Context)
{
glXMakeCurrent(WindowManager::GetDisplay(),
WindowHandle, Context);
XWindowAttributes l_Attributes;
XGetWindowAttributes(WindowManager::GetDisplay(),
WindowHandle, &l_Attributes);
Position[0] = l_Attributes.x;
Position[1] = l_Attributes.y;
const char* ExtensionsAvailable = 0;
ExtensionsAvailable = glXQueryExtensionsString(WindowManager::GetDisplay(), 0);
if(!ExtensionsAvailable)
{
PrintWarningMessage(WARNING_NOGLEXTENSIONS);
}
else
{
InitGLExtensions();
}
ContextCreated = GL_TRUE;
return FOUNDATION_OKAY;
}
}
else
{
PrintErrorMessage(ERROR_EXISTINGCONTEXT);
return FOUNDATION_ERROR;
}
return FOUNDATION_ERROR;
}
static void visualAttribs( Display * dpy, XVisualInfo * vi, VisualAttribs * attribs )
{
memset( attribs, 0, sizeof( VisualAttribs ) );
attribs->id = vi->visualid;
attribs->c_class = vi->c_class;
attribs->depth = vi->depth;
attribs->redMask = vi->red_mask;
attribs->greenMask = vi->green_mask;
attribs->blueMask = vi->blue_mask;
attribs->colormapSize = vi->colormap_size;
attribs->bitsPerRGB = vi->bits_per_rgb;
if ( glXGetConfig( dpy, vi, GLX_USE_GL, &attribs->supportsGL ) != 0 )
return;
attribs->accumAlphaSize = 0;
glXGetConfig( dpy, vi, GLX_BUFFER_SIZE, &attribs->bufferSize );
glXGetConfig( dpy, vi, GLX_LEVEL, &attribs->level );
glXGetConfig( dpy, vi, GLX_RGBA, &attribs->rgba );
glXGetConfig( dpy, vi, GLX_DOUBLEBUFFER, &attribs->doubleBuffer );
glXGetConfig( dpy, vi, GLX_STEREO, &attribs->stereo );
glXGetConfig( dpy, vi, GLX_AUX_BUFFERS, &attribs->auxBuffers );
glXGetConfig( dpy, vi, GLX_RED_SIZE, &attribs->redSize );
glXGetConfig( dpy, vi, GLX_GREEN_SIZE, &attribs->greenSize );
glXGetConfig( dpy, vi, GLX_BLUE_SIZE, &attribs->blueSize );
glXGetConfig( dpy, vi, GLX_ALPHA_SIZE, &attribs->alphaSize );
glXGetConfig( dpy, vi, GLX_DEPTH_SIZE, &attribs->depthSize );
glXGetConfig( dpy, vi, GLX_STENCIL_SIZE, &attribs->stencilSize );
glXGetConfig( dpy, vi, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize );
glXGetConfig( dpy, vi, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize );
glXGetConfig( dpy, vi, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize );
glXGetConfig( dpy, vi, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize );
attribs->transparent = 0; // transparent pixel missing
attribs->numSamples = 0; // multisample tests missing
attribs->numMultisample = 0;
#if defined(GLX_EXT_visual_rating)
const char *ext = glXQueryExtensionsString( dpy, vi->screen );
if ( ext && strstr( ext, "GLX_EXT_visual_rating" ) )
glXGetConfig(dpy, vi, GLX_VISUAL_CAVEAT_EXT, &attribs->visualCaveat);
else
attribs->visualCaveat = GLX_NONE_EXT;
#else
attribs->visualCaveat = 0;
#endif
}
bool GLPlatformContext::supportsGLXExtension(Display* display, const String& name)
{
static HashSet<String> supportedExtensions;
if (!supportedExtensions.size()) {
if (!display)
return false;
String rawExtensions = glXQueryExtensionsString(display, DefaultScreen(display));
supportedExtensions = parseExtensions(rawExtensions);
}
if (supportedExtensions.contains(name))
return true;
return false;
}
char * COpenGLExtentions::GetXGLExtensions()
{
Display *dpDisplay;
// Connect to X Server
dpDisplay = XOpenDisplay(NULL);
if(dpDisplay == NULL)
throw nova::NovaExp("COpenGLExtentions::GetXGLExtensions() - can not connect to X server!", BAD_OPERATION);
if(!glXQueryExtension(dpDisplay, NULL, NULL))
return NULL;
char * str = glXQueryExtensionsString(dpDisplay, DefaultScreen(dpDisplay));
XCloseDisplay(dpDisplay);
return str;
}
static GLXPixmap make_pixmap( Display *dpy, Window win,
unsigned int width, unsigned int height,
Pixmap *pixmap)
{
Pixmap pm;
GLXPixmap glxpm;
XWindowAttributes attr;
pm = XCreatePixmap( dpy, win, width, height, visinfo->depth );
if (!pm) {
printf("Error: XCreatePixmap failed\n");
exit(-1);
}
XGetWindowAttributes( dpy, win, &attr );
printf("pm %lx\n", pm);
/*
* IMPORTANT:
* Use the glXCreateGLXPixmapMESA funtion when using Mesa because
* Mesa needs to know the colormap associated with a pixmap in order
* to render correctly. This is because Mesa allows RGB rendering
* into any kind of visual, not just TrueColor or DirectColor.
*/
#ifdef GLX_MESA_pixmap_colormap
if (strstr(glXQueryExtensionsString(dpy, 0), "GLX_MESA_pixmap_colormap")) {
/* stand-alone Mesa, specify the colormap */
glxpm = glXCreateGLXPixmapMESA( dpy, visinfo, pm, attr.colormap );
}
else {
glxpm = glXCreateGLXPixmap( dpy, visinfo, pm );
}
#else
/* This will work with Mesa too if the visual is TrueColor or DirectColor */
glxpm = glXCreateGLXPixmap( dpy, visinfo, pm );
#endif
if (!glxpm) {
printf("Error: GLXCreateGLXPixmap failed\n");
exit(-1);
}
*pixmap = pm;
return glxpm;
}
void
init(void) {
display = XOpenDisplay(NULL);
if (!display) {
std::cerr << "error: unable to open display " << XDisplayName(NULL) << "\n";
exit(1);
}
screen = DefaultScreen(display);
int major = 0, minor = 0;
glXQueryVersion(display, &major, &minor);
glxVersion = (major << 8) | minor;
extensions = glXQueryExtensionsString(display, screen);
has_GLX_ARB_create_context = checkExtension("GLX_ARB_create_context", extensions);
}
bool CWinSystemX11GL::CreateNewWindow(const CStdString& name, bool fullScreen, RESOLUTION_INFO& res, PHANDLE_EVENT_FUNC userFunction)
{
if(!CWinSystemX11::CreateNewWindow(name, fullScreen, res, userFunction))
return false;
m_glxext = " ";
m_glxext += (const char*)glXQueryExtensionsString(m_dpy, DefaultScreen(m_dpy));
m_glxext += " ";
CLog::Log(LOGDEBUG, "GLX_EXTENSIONS:%s", m_glxext.c_str());
/* any time window is recreated we need new pointers */
if (IsExtSupported("GLX_OML_sync_control"))
m_glXGetSyncValuesOML = (Bool (*)(Display*, GLXDrawable, int64_t*, int64_t*, int64_t*))glXGetProcAddress((const GLubyte*)"glXGetSyncValuesOML");
else
m_glXGetSyncValuesOML = NULL;
if (IsExtSupported("GLX_OML_sync_control"))
m_glXSwapBuffersMscOML = (int64_t (*)(Display*, GLXDrawable, int64_t, int64_t, int64_t))glXGetProcAddress((const GLubyte*)"glXSwapBuffersMscOML");
else
m_glXSwapBuffersMscOML = NULL;
if (IsExtSupported("GLX_SGI_video_sync"))
m_glXWaitVideoSyncSGI = (int (*)(int, int, unsigned int*))glXGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI");
else
m_glXWaitVideoSyncSGI = NULL;
if (IsExtSupported("GLX_SGI_video_sync"))
m_glXGetVideoSyncSGI = (int (*)(unsigned int*))glXGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI");
else
m_glXGetVideoSyncSGI = NULL;
if (IsExtSupported("GLX_SGI_swap_control") )
m_glXSwapIntervalSGI = (int (*)(int))glXGetProcAddress((const GLubyte*)"glXSwapIntervalSGI");
else
m_glXSwapIntervalSGI = NULL;
if (IsExtSupported("GLX_MESA_swap_control"))
m_glXSwapIntervalMESA = (int (*)(int))glXGetProcAddress((const GLubyte*)"glXSwapIntervalMESA");
else
m_glXSwapIntervalMESA = NULL;
return true;
}
static void screenInfo( Display *dpy, int scrnum, QString &infotext )
{
const char *serverVendor = glXQueryServerString( dpy, scrnum, GLX_VENDOR );
const char *serverVersion = glXQueryServerString( dpy, scrnum, GLX_VERSION );
const char *serverExtensions = glXQueryServerString( dpy, scrnum, GLX_EXTENSIONS );
const char *clientVendor = glXGetClientString( dpy, GLX_VENDOR );
const char *clientVersion = glXGetClientString( dpy, GLX_VERSION );
const char *clientExtensions = glXGetClientString( dpy, GLX_EXTENSIONS );
const char *glxExtensions = glXQueryExtensionsString( dpy, scrnum );
const char *glVendor = (const char *) glGetString( GL_VENDOR );
const char *glRenderer = (const char *) glGetString( GL_RENDERER );
const char *glVersion = (const char *) glGetString( GL_VERSION );
const char *glExtensions = (const char *) glGetString( GL_EXTENSIONS );
const char *gluVersion = (const char *) gluGetString( (GLenum) GLU_VERSION );
const char *gluExtensions = (const char *) gluGetString( (GLenum) GLU_EXTENSIONS );
infotext.sprintf( "%sServer GLX vendor string: %s\n", infotext.ascii(), serverVendor );
infotext.sprintf( "%sServer GLX version string: %s\n", infotext.ascii(), serverVersion );
infotext.sprintf( "%sServer GLX extensions:\n", infotext.ascii() );
infotext += QString( serverExtensions ).replace( ' ', '\n' ) + "\n\n";
infotext.sprintf( "%sClient GLX vendor string: %s\n", infotext.ascii(), clientVendor );
infotext.sprintf( "%sClient GLX version string: %s\n", infotext.ascii(), clientVersion );
infotext.sprintf( "%sClient GLX extensions:\n", infotext.ascii() );
infotext += QString( clientExtensions ).replace( ' ', '\n' ) + "\n\n";
infotext.sprintf( "%sGLX extensions:\n", infotext.ascii() );
infotext += QString( glxExtensions ).replace( ' ', '\n' ) + "\n\n";
infotext.sprintf( "%sOpenGL vendor string: %s\n", infotext.ascii(), glVendor );
infotext.sprintf( "%sOpenGL renderer string: %s\n", infotext.ascii(), glRenderer );
infotext.sprintf( "%sOpenGL version string: %s\n", infotext.ascii(), glVersion );
infotext.sprintf( "%sOpenGL extensions:\n", infotext.ascii() );
infotext += QString( glExtensions ).replace( ' ', '\n' ) + "\n\n";
infotext.sprintf( "%sGLU version: %s\n", infotext.ascii(), gluVersion );
infotext.sprintf( "%sGLU extensions:\n", infotext.ascii() );
infotext += QString( gluExtensions ).replace( ' ', '\n' ) + "\n\n";
}
/* Returns 1 if the specified GLX extension is present, 0 if not. */
static int
is_glx_extension_present (Display * dpy, int screen, char * ext)
{
const char * str = glXQueryExtensionsString (dpy, screen);
if (!str)
return 0;
const char * a = str;
int extlen = strlen (ext);
while (*a) {
int len = strcspn (a, " ");
if (extlen == len && !strncmp (ext, a, len))
return 1;
a += len;
if (*a)
a++;
}
return 0;
}
static
void
check_glx_extensions(void)
{
const char *glx_ext_str = glXQueryExtensionsString(display.x, 0);
if (!glx_ext_str)
return;
display.glx_arb_create_context = !!strstr(glx_ext_str, "GLX_ARB_create_context");
display.glx_arb_create_context_profile = !!strstr(glx_ext_str,
"GLX_ARB_create_context_profile");
display.glx_ext_create_context_es2_profile = !!strstr(glx_ext_str,
"GLX_EXT_create_context_es2_profile");
display.glXCreateContextAttribsARB = (glx_create_context_attribs_arb_f)
glXGetProcAddressARB((const GLubyte *)"glXCreateContextAttribsARB");
display.glXBindTexImageEXT = (glx_bind_tex_image_ext_f)
glXGetProcAddress((GLubyte *)"glXBindTexImageEXT");
display.glXReleaseTexImageEXT = (glx_release_tex_image_ext_f)
glXGetProcAddress((GLubyte *)"glXReleaseTexImageEXT");
}
static int check_glx_extention(const char *ext) {
if (!ext || strchr(ext, ' ') || *ext == '\0') {
return 0;
}
const char *exts = glXQueryExtensionsString(_gl_display, _gl_screen);
if (!exts) {
return 0;
}
const char *start = exts;
while (1) {
const char *tmp = strstr(start, ext);
if (!tmp) break;
const char *end = tmp + strlen(ext);
if (tmp == start || *(tmp - 1) == ' ')
if (*end == ' ' || *end == '\0') return 1;
start = end;
}
return 0;
}
void
init(void) {
initX();
int major = 0, minor = 0;
glXQueryVersion(display, &major, &minor);
glxVersion = (major << 8) | minor;
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
}
static int GLXExtensionSupported(Display *dpy, const char *extension)
{
const char *extensionsString, *client_extensions, *pos;
extensionsString = glXQueryExtensionsString(dpy, DefaultScreen(dpy));
client_extensions = glXGetClientString(dpy, GLX_EXTENSIONS);
pos = strstr(extensionsString, extension);
if (pos != NULL && (pos == extensionsString || pos[-1] == ' ') &&
(pos[strlen(extension)] == ' ' || pos[strlen(extension)] == '\0'))
return 1;
pos = strstr(client_extensions, extension);
if (pos != NULL && (pos == extensionsString || pos[-1] == ' ') &&
(pos[strlen(extension)] == ' ' || pos[strlen(extension)] == '\0'))
return 1;
return 0;
}
bool isExtensionSupported ( const char * ext )
{
initExtensions (); // since we will need it for platform-specific extensions
const char * extensions = (const char *) glGetString ( GL_EXTENSIONS );
if ( isExtensionSupported ( ext, extensions ) )
return true;
#ifdef _WIN32 // check Windoze extensions
if ( wglGetExtensionsStringARB == NULL )
return false;
return isExtensionSupported ( ext, wglGetExtensionsStringARB ( wglGetCurrentDC () ) );
#else // check GLX extensions
Display * display = glXGetCurrentDisplay ();
int screen = DefaultScreen ( display );
return isExtensionSupported ( ext, glXQueryExtensionsString ( display, screen ) );
#endif
}
int
__glutIsSupportedByGLX(char *extension)
{
#if defined(GLX_VERSION_1_1)
static const char *extensions = NULL;
const char *start;
char *where, *terminator;
int major, minor;
glXQueryVersion(__glutDisplay, &major, &minor);
/* 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. */
if ((major == 1 && minor >= 1) || (major > 1)) {
if (!extensions)
extensions = glXQueryExtensionsString(__glutDisplay, __glutScreen);
/* 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)
return 0;
terminator = where + strlen(extension);
if (where == start || *(where - 1) == ' ') {
if (*terminator == ' ' || *terminator == '\0') {
return 1;
}
}
start = terminator;
}
}
#else
/* No GLX extensions before GLX 1.1 */
#endif
return 0;
}
//-------------------------------------------------------------------------------------------------//
void GLXGLSupport::initialiseExtensions(void)
{
assert (mGLDisplay);
GLSupport::initialiseExtensions();
const char* extensionsString;
// This is more realistic than using glXGetClientString:
extensionsString = glXQueryExtensionsString(mGLDisplay, DefaultScreen(mGLDisplay));
LogManager::getSingleton().stream() << "Supported GLX extensions: " << extensionsString;
std::stringstream ext;
String instr;
ext << extensionsString;
while(ext >> instr)
{
extensionList.insert(instr);
}
}
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);
}
static bool create_context_x11_old(struct MPGLContext *ctx)
{
struct glx_context *glx_ctx = ctx->priv;
Display *display = ctx->vo->x11->display;
struct vo *vo = ctx->vo;
GL *gl = ctx->gl;
if (glx_ctx->context)
return true;
if (!glx_ctx->vinfo) {
MP_FATAL(vo, "Can't create a legacy GLX context without X visual\n");
return false;
}
GLXContext new_context = glXCreateContext(display, glx_ctx->vinfo, NULL,
True);
if (!new_context) {
MP_FATAL(vo, "Could not create GLX context!\n");
return false;
}
if (!glXMakeCurrent(display, ctx->vo->x11->window, new_context)) {
MP_FATAL(vo, "Could not set GLX context!\n");
glXDestroyContext(display, new_context);
return false;
}
const char *glxstr = glXQueryExtensionsString(display, ctx->vo->x11->screen);
mpgl_load_functions(gl, (void *)glXGetProcAddressARB, glxstr, vo->log);
glx_ctx->context = new_context;
return true;
}
StWinGlrc::StWinGlrc(StHandle<StXDisplay>& theDisplay,
const bool theDebugCtx)
: myDisplay(theDisplay->hDisplay),
myRC(NULL) {
const char* aGlxExts = glXQueryExtensionsString(theDisplay->hDisplay, DefaultScreen(theDisplay->hDisplay));
if(StGLContext::stglCheckExtension(aGlxExts, "GLX_ARB_create_context_profile")) {
glXCreateContextAttribsARB_t aCreateCtxFunc = (glXCreateContextAttribsARB_t )glXGetProcAddress((const GLubyte* )"glXCreateContextAttribsARB");
int aCtxAttribs[] = {
//GLX_CONTEXT_MAJOR_VERSION_ARB, 2,
//GLX_CONTEXT_MINOR_VERSION_ARB, 0,
GLX_CONTEXT_FLAGS_ARB, theDebugCtx ? GLX_CONTEXT_DEBUG_BIT_ARB : 0,
//GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
None
};
myRC = aCreateCtxFunc(theDisplay->hDisplay, theDisplay->FBCfg, 0, True, aCtxAttribs);
}
if(myRC == NULL) {
// fallback compatibility mode
myRC = glXCreateContext(theDisplay->hDisplay, theDisplay->hVisInfo, None, true);
}
}
static bool gfx_ctx_glx_bind_api(void *data, enum gfx_ctx_api api,
unsigned major, unsigned minor)
{
(void)data;
g_major = major;
g_minor = minor;
#ifdef HAVE_OPENGLES2
Display *dpy = XOpenDisplay(NULL);
const char *exts = glXQueryExtensionsString(dpy, DefaultScreen(dpy));
bool ret = api == GFX_CTX_OPENGL_ES_API &&
exts && strstr(exts, "GLX_EXT_create_context_es2_profile");
XCloseDisplay(dpy);
if (ret && g_major < 3)
{
g_major = 2; /* ES 2.0. */
g_minor = 0;
}
return ret;
#else
return api == GFX_CTX_OPENGL_API;
#endif
}
static ClutterFeatureFlags
clutter_backend_glx_get_features (ClutterBackend *backend)
{
ClutterBackendGLX *backend_glx = CLUTTER_BACKEND_GLX (backend);
const gchar *glx_extensions = NULL;
const gchar *gl_extensions = NULL;
ClutterFeatureFlags flags;
gboolean use_dri = FALSE;
flags = clutter_backend_x11_get_features (backend);
flags |= CLUTTER_FEATURE_STAGE_MULTIPLE;
/* this will make sure that the GL context exists */
g_assert (backend_glx->gl_context != None);
g_assert (glXGetCurrentDrawable () != None);
CLUTTER_NOTE (BACKEND,
"Checking features\n"
" GL_VENDOR: %s\n"
" GL_RENDERER: %s\n"
" GL_VERSION: %s\n"
" GL_EXTENSIONS: %s",
glGetString (GL_VENDOR),
glGetString (GL_RENDERER),
glGetString (GL_VERSION),
glGetString (GL_EXTENSIONS));
glx_extensions =
glXQueryExtensionsString (clutter_x11_get_default_display (),
clutter_x11_get_default_screen ());
CLUTTER_NOTE (BACKEND, " GLX Extensions: %s", glx_extensions);
gl_extensions = (const gchar *)glGetString (GL_EXTENSIONS);
/* When using glBlitFramebuffer or glXCopySubBufferMESA for sub stage
* redraws, we cannot rely on glXSwapIntervalSGI to throttle the blits
* so we need to resort to manually synchronizing with the vblank so we
* always check for the video_sync extension...
*/
if (_cogl_check_extension ("GLX_SGI_video_sync", glx_extensions) &&
/* Note: the GLX_SGI_video_sync spec explicitly states this extension
* only works for direct contexts. */
glXIsDirect (clutter_x11_get_default_display (),
backend_glx->gl_context))
{
backend_glx->get_video_sync =
(GetVideoSyncProc) cogl_get_proc_address ("glXGetVideoSyncSGI");
backend_glx->wait_video_sync =
(WaitVideoSyncProc) cogl_get_proc_address ("glXWaitVideoSyncSGI");
}
use_dri = check_vblank_env ("dri");
/* First check for explicit disabling or it set elsewhere (eg NVIDIA) */
if (check_vblank_env ("none"))
{
CLUTTER_NOTE (BACKEND, "vblank sync: disabled at user request");
goto vblank_setup_done;
}
if (g_getenv ("__GL_SYNC_TO_VBLANK") != NULL)
{
backend_glx->vblank_type = CLUTTER_VBLANK_GLX_SWAP;
flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;
CLUTTER_NOTE (BACKEND, "Using __GL_SYNC_TO_VBLANK hint");
goto vblank_setup_done;
}
/* We try two GL vblank syncing mechanisms.
* glXSwapIntervalSGI is tried first, then glXGetVideoSyncSGI.
*
* glXSwapIntervalSGI is known to work with Mesa and in particular
* the Intel drivers. glXGetVideoSyncSGI has serious problems with
* Intel drivers causing terrible frame rate so it only tried as a
* fallback.
*
* How well glXGetVideoSyncSGI works with other driver (ATI etc) needs
* to be investigated. glXGetVideoSyncSGI on ATI at least seems to have
* no effect.
*/
if (!use_dri &&
_cogl_check_extension ("GLX_SGI_swap_control", glx_extensions))
{
backend_glx->swap_interval =
(SwapIntervalProc) cogl_get_proc_address ("glXSwapIntervalSGI");
CLUTTER_NOTE (BACKEND, "attempting glXSwapIntervalSGI vblank setup");
if (backend_glx->swap_interval != NULL &&
backend_glx->swap_interval (1) == 0)
{
backend_glx->vblank_type = CLUTTER_VBLANK_GLX_SWAP;
flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;
CLUTTER_NOTE (BACKEND, "glXSwapIntervalSGI setup success");
#ifdef GLX_INTEL_swap_event
/* GLX_INTEL_swap_event allows us to avoid blocking the CPU
* while we wait for glXSwapBuffers to complete, and instead
* we get an X event notifying us of completion...
*/
if (!(clutter_paint_debug_flags & CLUTTER_DEBUG_DISABLE_SWAP_EVENTS) &&
_cogl_check_extension ("GLX_INTEL_swap_event", glx_extensions))
{
flags |= CLUTTER_FEATURE_SWAP_EVENTS;
}
#endif /* GLX_INTEL_swap_event */
goto vblank_setup_done;
}
CLUTTER_NOTE (BACKEND, "glXSwapIntervalSGI vblank setup failed");
}
if (!use_dri &&
!(flags & CLUTTER_FEATURE_SYNC_TO_VBLANK) &&
_cogl_check_extension ("GLX_SGI_video_sync", glx_extensions))
{
CLUTTER_NOTE (BACKEND, "attempting glXGetVideoSyncSGI vblank setup");
if ((backend_glx->get_video_sync != NULL) &&
(backend_glx->wait_video_sync != NULL))
{
CLUTTER_NOTE (BACKEND, "glXGetVideoSyncSGI vblank setup success");
backend_glx->vblank_type = CLUTTER_VBLANK_GLX;
flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;
goto vblank_setup_done;
}
CLUTTER_NOTE (BACKEND, "glXGetVideoSyncSGI vblank setup failed");
}
#ifdef __linux__
/*
* DRI is really an extreme fallback -rumoured to work with Via chipsets
*/
if (!(flags & CLUTTER_FEATURE_SYNC_TO_VBLANK))
{
CLUTTER_NOTE (BACKEND, "attempting DRI vblank setup");
backend_glx->dri_fd = open("/dev/dri/card0", O_RDWR);
if (backend_glx->dri_fd >= 0)
{
CLUTTER_NOTE (BACKEND, "DRI vblank setup success");
backend_glx->vblank_type = CLUTTER_VBLANK_DRI;
flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;
goto vblank_setup_done;
}
CLUTTER_NOTE (BACKEND, "DRI vblank setup failed");
}
#endif /* __linux__ */
CLUTTER_NOTE (BACKEND, "no use-able vblank mechanism found");
vblank_setup_done:
if (_cogl_check_extension ("GLX_MESA_copy_sub_buffer", glx_extensions))
{
backend_glx->copy_sub_buffer =
(CopySubBufferProc) cogl_get_proc_address ("glXCopySubBufferMESA");
backend_glx->can_blit_sub_buffer = TRUE;
backend_glx->blit_sub_buffer_is_synchronized = TRUE;
}
else if (_cogl_check_extension ("GL_EXT_framebuffer_blit", gl_extensions))
{
CLUTTER_NOTE (BACKEND,
"Using glBlitFramebuffer fallback for sub_buffer copies");
backend_glx->blit_framebuffer =
(BlitFramebufferProc) cogl_get_proc_address ("glBlitFramebuffer");
backend_glx->can_blit_sub_buffer = TRUE;
backend_glx->blit_sub_buffer_is_synchronized = FALSE;
}
CLUTTER_NOTE (BACKEND, "backend features checked");
return flags;
}
