2007-03-22 14:21:59 -04:00
|
|
|
/* Clutter.
|
|
|
|
* An OpenGL based 'interactive canvas' library.
|
|
|
|
* Authored By Matthew Allum <mallum@openedhand.com>
|
|
|
|
* Copyright (C) 2006-2007 OpenedHand
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2010-03-01 07:56:10 -05:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
*
|
2007-03-22 14:21:59 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
2009-11-30 12:47:55 -05:00
|
|
|
#include <fcntl.h>
|
2007-03-22 14:21:59 -04:00
|
|
|
|
2009-01-06 07:11:07 -05:00
|
|
|
#include <glib/gi18n-lib.h>
|
|
|
|
|
2007-05-16 05:08:30 -04:00
|
|
|
#include <GL/glx.h>
|
2009-11-12 15:37:01 -05:00
|
|
|
#include <GL/glxext.h>
|
2007-05-16 05:08:30 -04:00
|
|
|
#include <GL/gl.h>
|
|
|
|
|
2007-03-22 14:21:59 -04:00
|
|
|
#include "clutter-backend-glx.h"
|
|
|
|
#include "clutter-stage-glx.h"
|
2007-05-16 05:08:30 -04:00
|
|
|
#include "clutter-glx.h"
|
2009-03-30 11:41:02 -04:00
|
|
|
#include "clutter-profile.h"
|
2007-03-22 14:21:59 -04:00
|
|
|
|
2010-10-21 06:29:09 -04:00
|
|
|
#include "clutter-debug.h"
|
event/x11: Rework the way we translate X11 events
This is a lump commit that is fairly difficult to break down without
either breaking bisecting or breaking the test cases.
The new design for handling X11 event translation works this way:
- ClutterBackend::translate_event() has been added as the central
point used by a ClutterBackend implementation to translate a
native event into a ClutterEvent;
- ClutterEventTranslator is a private interface that should be
implemented by backend-specific objects, like stage
implementations and ClutterDeviceManager sub-classes, and
allows dealing with class-specific event translation;
- ClutterStageX11 implements EventTranslator, and deals with the
stage-relative X11 events coming from the X11 event source;
- ClutterStageGLX overrides EventTranslator, in order to
deal with the INTEL_GLX_swap_event extension, and it chains up
to the X11 default implementation;
- ClutterDeviceManagerX11 has been split into two separate classes,
one that deals with core and (optionally) XI1 events, and the
other that deals with XI2 events; the selection is done at run-time,
since the core+XI1 and XI2 mechanisms are mutually exclusive.
All the other backends we officially support still use their own
custom event source and translation function, but the end goal is to
migrate them to the translate_event() virtual function, and have the
event source be a shared part of Clutter core.
2011-01-04 07:32:04 -05:00
|
|
|
#include "clutter-event-translator.h"
|
2010-10-21 06:29:09 -04:00
|
|
|
#include "clutter-event.h"
|
|
|
|
#include "clutter-main.h"
|
|
|
|
#include "clutter-private.h"
|
|
|
|
#include "clutter-stage-private.h"
|
2007-03-22 14:21:59 -04:00
|
|
|
|
2008-04-25 09:37:36 -04:00
|
|
|
#include "cogl/cogl.h"
|
2007-05-16 05:08:30 -04:00
|
|
|
|
2011-01-21 05:49:12 -05:00
|
|
|
#define clutter_backend_glx_get_type _clutter_backend_glx_get_type
|
2009-03-30 11:41:02 -04:00
|
|
|
|
2011-01-21 05:49:12 -05:00
|
|
|
G_DEFINE_TYPE (ClutterBackendGLX, clutter_backend_glx, CLUTTER_TYPE_BACKEND_X11);
|
2007-03-22 14:21:59 -04:00
|
|
|
|
|
|
|
/* singleton object */
|
2007-05-31 07:13:43 -04:00
|
|
|
static ClutterBackendGLX *backend_singleton = NULL;
|
2007-03-22 14:21:59 -04:00
|
|
|
|
2009-12-01 11:18:39 -05:00
|
|
|
static gchar *clutter_vblank_name = NULL;
|
2007-05-16 05:08:30 -04:00
|
|
|
|
|
|
|
G_CONST_RETURN gchar*
|
2010-08-13 10:48:30 -04:00
|
|
|
_clutter_backend_glx_get_vblank_method (void)
|
2007-05-16 05:08:30 -04:00
|
|
|
{
|
|
|
|
return clutter_vblank_name;
|
|
|
|
}
|
|
|
|
|
2007-03-22 14:21:59 -04:00
|
|
|
static gboolean
|
|
|
|
clutter_backend_glx_pre_parse (ClutterBackend *backend,
|
|
|
|
GError **error)
|
|
|
|
{
|
2011-01-20 10:39:28 -05:00
|
|
|
ClutterBackendClass *parent_class =
|
2011-01-21 05:49:12 -05:00
|
|
|
CLUTTER_BACKEND_CLASS (clutter_backend_glx_parent_class);
|
2007-03-22 14:21:59 -04:00
|
|
|
const gchar *env_string;
|
|
|
|
|
2007-05-16 05:08:30 -04:00
|
|
|
env_string = g_getenv ("CLUTTER_VBLANK");
|
|
|
|
if (env_string)
|
|
|
|
{
|
|
|
|
clutter_vblank_name = g_strdup (env_string);
|
|
|
|
env_string = NULL;
|
|
|
|
}
|
|
|
|
|
2011-01-20 10:39:28 -05:00
|
|
|
return parent_class->pre_parse (backend, error);
|
2007-03-22 14:21:59 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
clutter_backend_glx_post_parse (ClutterBackend *backend,
|
|
|
|
GError **error)
|
|
|
|
{
|
2007-11-15 09:45:27 -05:00
|
|
|
ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend);
|
2009-11-12 15:37:01 -05:00
|
|
|
ClutterBackendGLX *backend_glx = CLUTTER_BACKEND_GLX (backend);
|
2011-01-20 10:39:28 -05:00
|
|
|
ClutterBackendClass *parent_class =
|
2011-01-21 05:49:12 -05:00
|
|
|
CLUTTER_BACKEND_CLASS (clutter_backend_glx_parent_class);
|
2007-11-15 09:45:27 -05:00
|
|
|
int glx_major, glx_minor;
|
2007-03-22 14:21:59 -04:00
|
|
|
|
2011-01-20 10:39:28 -05:00
|
|
|
if (!parent_class->post_parse (backend, error))
|
2009-11-12 15:37:01 -05:00
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
if (!glXQueryExtension (backend_x11->xdpy,
|
|
|
|
&backend_glx->error_base,
|
|
|
|
&backend_glx->event_base))
|
2007-03-22 14:21:59 -04:00
|
|
|
{
|
2009-11-12 15:37:01 -05:00
|
|
|
g_set_error (error, CLUTTER_INIT_ERROR,
|
|
|
|
CLUTTER_INIT_ERROR_BACKEND,
|
|
|
|
"XServer appears to lack required GLX support");
|
2008-10-31 08:48:26 -04:00
|
|
|
|
2009-11-12 15:37:01 -05:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX: Technically we should require >= GLX 1.3 support but for a long
|
|
|
|
* time Mesa has exported a hybrid GLX, exporting extensions specified
|
|
|
|
* to require GLX 1.3, but still reporting 1.2 via glXQueryVersion. */
|
event/x11: Rework the way we translate X11 events
This is a lump commit that is fairly difficult to break down without
either breaking bisecting or breaking the test cases.
The new design for handling X11 event translation works this way:
- ClutterBackend::translate_event() has been added as the central
point used by a ClutterBackend implementation to translate a
native event into a ClutterEvent;
- ClutterEventTranslator is a private interface that should be
implemented by backend-specific objects, like stage
implementations and ClutterDeviceManager sub-classes, and
allows dealing with class-specific event translation;
- ClutterStageX11 implements EventTranslator, and deals with the
stage-relative X11 events coming from the X11 event source;
- ClutterStageGLX overrides EventTranslator, in order to
deal with the INTEL_GLX_swap_event extension, and it chains up
to the X11 default implementation;
- ClutterDeviceManagerX11 has been split into two separate classes,
one that deals with core and (optionally) XI1 events, and the
other that deals with XI2 events; the selection is done at run-time,
since the core+XI1 and XI2 mechanisms are mutually exclusive.
All the other backends we officially support still use their own
custom event source and translation function, but the end goal is to
migrate them to the translate_event() virtual function, and have the
event source be a shared part of Clutter core.
2011-01-04 07:32:04 -05:00
|
|
|
if (!glXQueryVersion (backend_x11->xdpy, &glx_major, &glx_minor) ||
|
|
|
|
!(glx_major == 1 && glx_minor >= 2))
|
2009-11-12 15:37:01 -05:00
|
|
|
{
|
|
|
|
g_set_error (error, CLUTTER_INIT_ERROR,
|
|
|
|
CLUTTER_INIT_ERROR_BACKEND,
|
|
|
|
"XServer appears to lack required GLX 1.2 support");
|
|
|
|
return FALSE;
|
2007-03-22 14:21:59 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const GOptionEntry entries[] =
|
|
|
|
{
|
2009-07-31 15:39:28 -04:00
|
|
|
{ "vblank", 0,
|
|
|
|
0,
|
2007-05-16 05:08:30 -04:00
|
|
|
G_OPTION_ARG_STRING, &clutter_vblank_name,
|
2009-01-06 07:11:07 -05:00
|
|
|
N_("VBlank method to be used (none, dri or glx)"), "METHOD"
|
2007-05-16 05:08:30 -04:00
|
|
|
},
|
2007-03-22 14:21:59 -04:00
|
|
|
{ NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_backend_glx_add_options (ClutterBackend *backend,
|
|
|
|
GOptionGroup *group)
|
|
|
|
{
|
2011-01-20 10:39:28 -05:00
|
|
|
ClutterBackendClass *parent_class =
|
2011-01-21 05:49:12 -05:00
|
|
|
CLUTTER_BACKEND_CLASS (clutter_backend_glx_parent_class);
|
2011-01-20 10:39:28 -05:00
|
|
|
|
2007-03-22 14:21:59 -04:00
|
|
|
g_option_group_add_entries (group, entries);
|
2011-01-20 10:39:28 -05:00
|
|
|
|
|
|
|
parent_class->add_options (backend, group);
|
2007-03-22 14:21:59 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_backend_glx_finalize (GObject *gobject)
|
|
|
|
{
|
|
|
|
if (backend_singleton)
|
|
|
|
backend_singleton = NULL;
|
|
|
|
|
2011-01-21 05:49:12 -05:00
|
|
|
G_OBJECT_CLASS (clutter_backend_glx_parent_class)->finalize (gobject);
|
2007-03-22 14:21:59 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_backend_glx_dispose (GObject *gobject)
|
|
|
|
{
|
2008-04-04 11:02:11 -04:00
|
|
|
ClutterBackendGLX *backend_glx = CLUTTER_BACKEND_GLX (gobject);
|
|
|
|
ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (gobject);
|
|
|
|
|
2008-05-13 06:42:36 -04:00
|
|
|
/* Unrealize all shaders, since the GL context is going away */
|
|
|
|
_clutter_shader_release_all ();
|
|
|
|
|
2008-04-04 11:02:11 -04:00
|
|
|
if (backend_glx->gl_context)
|
|
|
|
{
|
2009-12-03 15:49:54 -05:00
|
|
|
glXMakeContextCurrent (backend_x11->xdpy, None, None, NULL);
|
2008-04-04 11:02:11 -04:00
|
|
|
glXDestroyContext (backend_x11->xdpy, backend_glx->gl_context);
|
2010-05-27 04:07:11 -04:00
|
|
|
backend_glx->gl_context = NULL;
|
2008-04-04 11:02:11 -04:00
|
|
|
}
|
|
|
|
|
2010-01-14 09:03:23 -05:00
|
|
|
if (backend_glx->dummy_glxwin)
|
|
|
|
{
|
|
|
|
glXDestroyWindow (backend_x11->xdpy, backend_glx->dummy_glxwin);
|
|
|
|
backend_glx->dummy_glxwin = None;
|
|
|
|
}
|
|
|
|
|
2009-12-03 15:49:54 -05:00
|
|
|
if (backend_glx->dummy_xwin)
|
|
|
|
{
|
|
|
|
XDestroyWindow (backend_x11->xdpy, backend_glx->dummy_xwin);
|
|
|
|
backend_glx->dummy_xwin = None;
|
|
|
|
}
|
|
|
|
|
2011-01-21 05:49:12 -05:00
|
|
|
G_OBJECT_CLASS (clutter_backend_glx_parent_class)->dispose (gobject);
|
2007-03-22 14:21:59 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static GObject *
|
|
|
|
clutter_backend_glx_constructor (GType gtype,
|
|
|
|
guint n_params,
|
|
|
|
GObjectConstructParam *params)
|
|
|
|
{
|
|
|
|
GObjectClass *parent_class;
|
|
|
|
GObject *retval;
|
|
|
|
|
|
|
|
if (!backend_singleton)
|
|
|
|
{
|
2011-01-21 05:49:12 -05:00
|
|
|
parent_class = G_OBJECT_CLASS (clutter_backend_glx_parent_class);
|
2007-03-22 14:21:59 -04:00
|
|
|
retval = parent_class->constructor (gtype, n_params, params);
|
|
|
|
|
|
|
|
backend_singleton = CLUTTER_BACKEND_GLX (retval);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_warning ("Attempting to create a new backend object. This should "
|
|
|
|
"never happen, so we return the singleton instance.");
|
2009-07-31 15:39:28 -04:00
|
|
|
|
2007-03-22 14:21:59 -04:00
|
|
|
return g_object_ref (backend_singleton);
|
|
|
|
}
|
|
|
|
|
2007-05-16 05:08:30 -04:00
|
|
|
static gboolean
|
|
|
|
check_vblank_env (const char *name)
|
|
|
|
{
|
2009-05-25 07:42:17 -04:00
|
|
|
if (clutter_vblank_name && !g_ascii_strcasecmp (clutter_vblank_name, name))
|
2007-05-16 05:08:30 -04:00
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ClutterFeatureFlags
|
|
|
|
clutter_backend_glx_get_features (ClutterBackend *backend)
|
|
|
|
{
|
2009-12-03 12:13:44 -05:00
|
|
|
ClutterBackendGLX *backend_glx = CLUTTER_BACKEND_GLX (backend);
|
2011-01-20 10:39:28 -05:00
|
|
|
ClutterBackendClass *parent_class;
|
2009-12-03 12:13:44 -05:00
|
|
|
const gchar *glx_extensions = NULL;
|
2010-06-05 06:51:32 -04:00
|
|
|
const gchar *gl_extensions = NULL;
|
2008-04-04 11:02:11 -04:00
|
|
|
ClutterFeatureFlags flags;
|
2010-02-25 13:28:37 -05:00
|
|
|
gboolean use_dri = FALSE;
|
2009-07-31 15:39:28 -04:00
|
|
|
|
2011-01-21 05:49:12 -05:00
|
|
|
parent_class = CLUTTER_BACKEND_CLASS (clutter_backend_glx_parent_class);
|
2011-01-20 10:39:28 -05:00
|
|
|
|
|
|
|
flags = parent_class->get_features (backend);
|
2008-04-04 11:02:11 -04:00
|
|
|
flags |= CLUTTER_FEATURE_STAGE_MULTIPLE;
|
2007-05-16 05:08:30 -04:00
|
|
|
|
2009-12-03 12:13:44 -05:00
|
|
|
/* this will make sure that the GL context exists */
|
2010-05-27 04:07:11 -04:00
|
|
|
g_assert (backend_glx->gl_context != NULL);
|
2009-12-03 15:49:54 -05:00
|
|
|
g_assert (glXGetCurrentDrawable () != None);
|
2009-12-03 12:13:44 -05:00
|
|
|
|
|
|
|
CLUTTER_NOTE (BACKEND,
|
|
|
|
"Checking features\n"
|
|
|
|
" GL_VENDOR: %s\n"
|
|
|
|
" GL_RENDERER: %s\n"
|
|
|
|
" GL_VERSION: %s\n"
|
2010-02-25 13:28:37 -05:00
|
|
|
" GL_EXTENSIONS: %s",
|
2008-01-31 18:10:30 -05:00
|
|
|
glGetString (GL_VENDOR),
|
|
|
|
glGetString (GL_RENDERER),
|
|
|
|
glGetString (GL_VERSION),
|
|
|
|
glGetString (GL_EXTENSIONS));
|
2007-06-14 08:54:47 -04:00
|
|
|
|
2009-07-31 15:39:28 -04:00
|
|
|
glx_extensions =
|
2007-11-15 09:45:27 -05:00
|
|
|
glXQueryExtensionsString (clutter_x11_get_default_display (),
|
2010-02-25 13:28:37 -05:00
|
|
|
clutter_x11_get_default_screen ());
|
2007-05-16 05:08:30 -04:00
|
|
|
|
2010-02-25 13:28:37 -05:00
|
|
|
CLUTTER_NOTE (BACKEND, " GLX Extensions: %s", glx_extensions);
|
|
|
|
|
2010-06-05 06:51:32 -04:00
|
|
|
gl_extensions = (const gchar *)glGetString (GL_EXTENSIONS);
|
|
|
|
|
2010-06-03 15:03:20 -04:00
|
|
|
/* 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...
|
|
|
|
*/
|
2010-06-03 18:12:08 -04:00
|
|
|
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))
|
2010-06-03 15:03:20 -04:00
|
|
|
{
|
|
|
|
backend_glx->get_video_sync =
|
|
|
|
(GetVideoSyncProc) cogl_get_proc_address ("glXGetVideoSyncSGI");
|
|
|
|
|
|
|
|
backend_glx->wait_video_sync =
|
|
|
|
(WaitVideoSyncProc) cogl_get_proc_address ("glXWaitVideoSyncSGI");
|
|
|
|
}
|
|
|
|
|
2010-02-25 13:28:37 -05:00
|
|
|
use_dri = check_vblank_env ("dri");
|
2007-06-14 08:54:47 -04:00
|
|
|
|
|
|
|
/* First check for explicit disabling or it set elsewhere (eg NVIDIA) */
|
2010-02-25 13:28:37 -05:00
|
|
|
if (check_vblank_env ("none"))
|
2007-05-16 05:08:30 -04:00
|
|
|
{
|
2007-06-14 08:54:47 -04:00
|
|
|
CLUTTER_NOTE (BACKEND, "vblank sync: disabled at user request");
|
2009-11-30 12:47:55 -05:00
|
|
|
goto vblank_setup_done;
|
2007-05-16 05:08:30 -04:00
|
|
|
}
|
2010-02-25 13:28:37 -05:00
|
|
|
|
|
|
|
if (g_getenv ("__GL_SYNC_TO_VBLANK") != NULL)
|
2007-05-16 05:08:30 -04:00
|
|
|
{
|
2010-02-25 13:28:37 -05:00
|
|
|
backend_glx->vblank_type = CLUTTER_VBLANK_GLX_SWAP;
|
|
|
|
flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;
|
2008-01-31 18:10:30 -05:00
|
|
|
|
2010-02-25 13:28:37 -05:00
|
|
|
CLUTTER_NOTE (BACKEND, "Using __GL_SYNC_TO_VBLANK hint");
|
2009-11-30 12:47:55 -05:00
|
|
|
goto vblank_setup_done;
|
2010-02-25 13:28:37 -05:00
|
|
|
}
|
2008-01-31 18:10:30 -05:00
|
|
|
|
2010-02-25 13:28:37 -05:00
|
|
|
/* 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");
|
2008-01-31 18:10:30 -05:00
|
|
|
|
2010-02-25 13:28:37 -05:00
|
|
|
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");
|
2009-11-12 15:37:01 -05:00
|
|
|
|
|
|
|
#ifdef GLX_INTEL_swap_event
|
2010-02-25 13:28:37 -05:00
|
|
|
/* 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...
|
|
|
|
*/
|
2010-02-16 15:08:35 -05:00
|
|
|
if (!(clutter_paint_debug_flags & CLUTTER_DEBUG_DISABLE_SWAP_EVENTS) &&
|
2010-02-25 13:28:37 -05:00
|
|
|
_cogl_check_extension ("GLX_INTEL_swap_event", glx_extensions))
|
2010-02-16 15:08:35 -05:00
|
|
|
{
|
|
|
|
flags |= CLUTTER_FEATURE_SWAP_EVENTS;
|
|
|
|
}
|
2009-11-12 15:37:01 -05:00
|
|
|
#endif /* GLX_INTEL_swap_event */
|
2010-02-25 13:28:37 -05:00
|
|
|
|
2009-11-30 12:47:55 -05:00
|
|
|
goto vblank_setup_done;
|
2008-01-31 18:10:30 -05:00
|
|
|
}
|
2007-06-14 08:54:47 -04:00
|
|
|
|
2010-02-25 13:28:37 -05:00
|
|
|
CLUTTER_NOTE (BACKEND, "glXSwapIntervalSGI vblank setup failed");
|
|
|
|
}
|
2008-01-31 18:10:30 -05:00
|
|
|
|
2010-02-25 13:28:37 -05:00
|
|
|
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");
|
2008-01-31 18:10:30 -05:00
|
|
|
|
2010-02-25 13:28:37 -05:00
|
|
|
if ((backend_glx->get_video_sync != NULL) &&
|
|
|
|
(backend_glx->wait_video_sync != NULL))
|
|
|
|
{
|
|
|
|
CLUTTER_NOTE (BACKEND, "glXGetVideoSyncSGI vblank setup success");
|
2007-06-14 08:54:47 -04:00
|
|
|
|
2010-02-25 13:28:37 -05:00
|
|
|
backend_glx->vblank_type = CLUTTER_VBLANK_GLX;
|
|
|
|
flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;
|
|
|
|
|
2009-11-30 12:47:55 -05:00
|
|
|
goto vblank_setup_done;
|
2008-01-31 18:10:30 -05:00
|
|
|
}
|
2009-12-03 12:13:44 -05:00
|
|
|
|
2010-02-25 13:28:37 -05:00
|
|
|
CLUTTER_NOTE (BACKEND, "glXGetVideoSyncSGI vblank setup failed");
|
|
|
|
}
|
|
|
|
|
2007-05-16 05:08:30 -04:00
|
|
|
#ifdef __linux__
|
2010-02-25 13:28:37 -05:00
|
|
|
/*
|
|
|
|
* 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)
|
2008-01-31 18:10:30 -05:00
|
|
|
{
|
2010-02-25 13:28:37 -05:00
|
|
|
CLUTTER_NOTE (BACKEND, "DRI vblank setup success");
|
2008-01-31 18:10:30 -05:00
|
|
|
|
2010-02-25 13:28:37 -05:00
|
|
|
backend_glx->vblank_type = CLUTTER_VBLANK_DRI;
|
|
|
|
flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;
|
|
|
|
|
2009-11-30 12:47:55 -05:00
|
|
|
goto vblank_setup_done;
|
2008-01-31 18:10:30 -05:00
|
|
|
}
|
2009-12-03 12:13:44 -05:00
|
|
|
|
2010-02-25 13:28:37 -05:00
|
|
|
CLUTTER_NOTE (BACKEND, "DRI vblank setup failed");
|
2007-05-16 05:08:30 -04:00
|
|
|
}
|
2010-02-25 13:28:37 -05:00
|
|
|
#endif /* __linux__ */
|
|
|
|
|
|
|
|
CLUTTER_NOTE (BACKEND, "no use-able vblank mechanism found");
|
2007-05-16 05:08:30 -04:00
|
|
|
|
2009-11-30 12:47:55 -05:00
|
|
|
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");
|
2010-06-05 06:51:32 -04:00
|
|
|
backend_glx->can_blit_sub_buffer = TRUE;
|
2010-06-03 15:03:20 -04:00
|
|
|
backend_glx->blit_sub_buffer_is_synchronized = TRUE;
|
2010-06-05 06:51:32 -04:00
|
|
|
}
|
|
|
|
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;
|
2010-06-03 15:03:20 -04:00
|
|
|
backend_glx->blit_sub_buffer_is_synchronized = FALSE;
|
2009-11-30 12:47:55 -05:00
|
|
|
}
|
|
|
|
|
2009-12-03 12:13:44 -05:00
|
|
|
CLUTTER_NOTE (BACKEND, "backend features checked");
|
|
|
|
|
2008-04-04 11:02:11 -04:00
|
|
|
return flags;
|
2007-05-16 05:08:30 -04:00
|
|
|
}
|
|
|
|
|
2009-08-03 09:50:10 -04:00
|
|
|
/* It seems the GLX spec never defined an invalid GLXFBConfig that
|
|
|
|
* we could overload as an indication of error, so we have to return
|
|
|
|
* an explicit boolean status. */
|
|
|
|
gboolean
|
|
|
|
_clutter_backend_glx_get_fbconfig (ClutterBackendGLX *backend_glx,
|
|
|
|
GLXFBConfig *config)
|
2009-07-31 12:07:10 -04:00
|
|
|
{
|
2009-08-03 09:50:10 -04:00
|
|
|
ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend_glx);
|
2009-12-01 11:18:39 -05:00
|
|
|
GLXFBConfig *configs = NULL;
|
2010-01-08 10:04:56 -05:00
|
|
|
gboolean use_argb = clutter_x11_get_use_argb_visual ();
|
2009-12-01 11:18:39 -05:00
|
|
|
int n_configs, i;
|
2010-01-07 10:58:53 -05:00
|
|
|
static const int attributes[] = {
|
2009-12-01 11:18:39 -05:00
|
|
|
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
|
|
|
|
GLX_RENDER_TYPE, GLX_RGBA_BIT,
|
|
|
|
GLX_DOUBLEBUFFER, GL_TRUE,
|
|
|
|
GLX_RED_SIZE, 1,
|
|
|
|
GLX_GREEN_SIZE, 1,
|
|
|
|
GLX_BLUE_SIZE, 1,
|
|
|
|
GLX_ALPHA_SIZE, 1,
|
|
|
|
GLX_DEPTH_SIZE, 1,
|
|
|
|
GLX_STENCIL_SIZE, 1,
|
2009-07-31 12:07:10 -04:00
|
|
|
None
|
|
|
|
};
|
|
|
|
|
2010-05-27 04:07:11 -04:00
|
|
|
if (backend_x11->xdpy == NULL || backend_x11->xscreen == NULL)
|
2009-07-31 12:07:10 -04:00
|
|
|
return FALSE;
|
|
|
|
|
2010-01-07 10:58:53 -05:00
|
|
|
/* If we don't already have a cached config then try to get one */
|
|
|
|
if (!backend_glx->found_fbconfig)
|
2009-08-03 09:50:10 -04:00
|
|
|
{
|
2010-01-07 10:58:53 -05:00
|
|
|
CLUTTER_NOTE (BACKEND,
|
|
|
|
"Retrieving GL fbconfig, dpy: %p, xscreen; %p (%d)",
|
|
|
|
backend_x11->xdpy,
|
|
|
|
backend_x11->xscreen,
|
|
|
|
backend_x11->xscreen_num);
|
|
|
|
|
|
|
|
configs = glXChooseFBConfig (backend_x11->xdpy,
|
|
|
|
backend_x11->xscreen_num,
|
|
|
|
attributes,
|
|
|
|
&n_configs);
|
|
|
|
if (configs)
|
2009-12-01 11:18:39 -05:00
|
|
|
{
|
2010-01-07 10:58:53 -05:00
|
|
|
if (use_argb)
|
|
|
|
{
|
|
|
|
for (i = 0; i < n_configs; i++)
|
|
|
|
{
|
|
|
|
XVisualInfo *vinfo;
|
|
|
|
|
|
|
|
vinfo = glXGetVisualFromFBConfig (backend_x11->xdpy,
|
|
|
|
configs[i]);
|
2010-05-27 04:07:11 -04:00
|
|
|
if (vinfo == NULL)
|
2010-01-07 10:58:53 -05:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (vinfo->depth == 32 &&
|
|
|
|
(vinfo->red_mask == 0xff0000 &&
|
|
|
|
vinfo->green_mask == 0x00ff00 &&
|
|
|
|
vinfo->blue_mask == 0x0000ff))
|
|
|
|
{
|
|
|
|
CLUTTER_NOTE (BACKEND,
|
2010-08-03 12:53:58 -04:00
|
|
|
"Found an ARGB FBConfig [index:%d]",
|
|
|
|
i);
|
2010-01-07 10:58:53 -05:00
|
|
|
|
|
|
|
backend_glx->found_fbconfig = TRUE;
|
|
|
|
backend_glx->fbconfig = configs[i];
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2009-12-01 11:18:39 -05:00
|
|
|
|
2010-01-07 10:58:53 -05:00
|
|
|
/* If we make it here then we didn't find an RGBA config so
|
|
|
|
we'll fall back to using an RGB config */
|
|
|
|
CLUTTER_NOTE (BACKEND, "ARGB visual requested, but none found");
|
|
|
|
}
|
2009-12-01 11:18:39 -05:00
|
|
|
|
2010-01-07 10:58:53 -05:00
|
|
|
if (n_configs >= 1)
|
|
|
|
{
|
2010-08-03 12:53:58 -04:00
|
|
|
CLUTTER_NOTE (BACKEND, "Using the first available FBConfig");
|
2010-01-07 10:58:53 -05:00
|
|
|
backend_glx->found_fbconfig = TRUE;
|
|
|
|
backend_glx->fbconfig = configs[0];
|
|
|
|
}
|
2009-12-01 11:18:39 -05:00
|
|
|
|
2010-01-07 10:58:53 -05:00
|
|
|
out:
|
|
|
|
XFree (configs);
|
2009-12-01 11:18:39 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-03 12:53:58 -04:00
|
|
|
if (G_LIKELY (backend_glx->found_fbconfig))
|
2009-12-01 11:18:39 -05:00
|
|
|
{
|
2010-01-07 10:58:53 -05:00
|
|
|
*config = backend_glx->fbconfig;
|
2009-12-01 11:18:39 -05:00
|
|
|
|
2010-01-07 10:58:53 -05:00
|
|
|
return TRUE;
|
2009-12-01 11:18:39 -05:00
|
|
|
}
|
2010-08-03 12:53:58 -04:00
|
|
|
|
|
|
|
return FALSE;
|
2009-07-31 12:07:10 -04:00
|
|
|
}
|
|
|
|
|
2010-06-05 06:51:32 -04:00
|
|
|
void
|
|
|
|
_clutter_backend_glx_blit_sub_buffer (ClutterBackendGLX *backend_glx,
|
2011-01-28 13:05:06 -05:00
|
|
|
GLXDrawable drawable,
|
|
|
|
int x,
|
|
|
|
int y,
|
|
|
|
int width,
|
|
|
|
int height)
|
2010-06-05 06:51:32 -04:00
|
|
|
{
|
|
|
|
ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend_glx);
|
|
|
|
|
|
|
|
if (backend_glx->copy_sub_buffer)
|
|
|
|
{
|
|
|
|
backend_glx->copy_sub_buffer (backend_x11->xdpy, drawable,
|
|
|
|
x, y, width, height);
|
|
|
|
}
|
|
|
|
else if (backend_glx->blit_framebuffer)
|
|
|
|
{
|
|
|
|
glDrawBuffer (GL_FRONT);
|
|
|
|
backend_glx->blit_framebuffer (x, y, x + width, y + height,
|
|
|
|
x, y, x + width, y + height,
|
|
|
|
GL_COLOR_BUFFER_BIT, GL_NEAREST);
|
|
|
|
glDrawBuffer (GL_BACK);
|
|
|
|
}
|
2011-02-12 18:04:52 -05:00
|
|
|
|
|
|
|
/* NB: unlike glXSwapBuffers, glXCopySubBuffer and
|
|
|
|
* glBlitFramebuffer don't issue an implicit glFlush() so we
|
|
|
|
* have to flush ourselves if we want the request to complete in
|
|
|
|
* finite amount of time since otherwise the driver can batch
|
|
|
|
* the command indefinitely. */
|
|
|
|
glFlush();
|
2010-06-05 06:51:32 -04:00
|
|
|
}
|
|
|
|
|
2009-07-31 12:07:10 -04:00
|
|
|
static XVisualInfo *
|
|
|
|
clutter_backend_glx_get_visual_info (ClutterBackendX11 *backend_x11)
|
|
|
|
{
|
2009-08-03 09:50:10 -04:00
|
|
|
ClutterBackendGLX *backend_glx = CLUTTER_BACKEND_GLX (backend_x11);
|
2009-07-31 12:07:10 -04:00
|
|
|
GLXFBConfig config;
|
|
|
|
|
2009-08-03 09:50:10 -04:00
|
|
|
if (!_clutter_backend_glx_get_fbconfig (backend_glx, &config))
|
2009-07-31 12:07:10 -04:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return glXGetVisualFromFBConfig (backend_x11->xdpy, config);
|
|
|
|
}
|
|
|
|
|
2009-05-13 17:21:48 -04:00
|
|
|
static gboolean
|
|
|
|
clutter_backend_glx_create_context (ClutterBackend *backend,
|
|
|
|
GError **error)
|
|
|
|
{
|
|
|
|
ClutterBackendGLX *backend_glx = CLUTTER_BACKEND_GLX (backend);
|
2010-01-14 09:03:23 -05:00
|
|
|
ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend);
|
2009-12-03 15:49:54 -05:00
|
|
|
GLXFBConfig config;
|
|
|
|
gboolean is_direct;
|
|
|
|
Window root_xwin;
|
|
|
|
XSetWindowAttributes attrs;
|
|
|
|
XVisualInfo *xvisinfo;
|
|
|
|
Display *xdisplay;
|
2010-01-14 09:03:23 -05:00
|
|
|
int major;
|
|
|
|
int minor;
|
|
|
|
GLXDrawable dummy_drawable;
|
2009-05-13 17:21:48 -04:00
|
|
|
|
2010-05-27 04:07:11 -04:00
|
|
|
if (backend_glx->gl_context != NULL)
|
2009-12-03 15:49:54 -05:00
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
xdisplay = clutter_x11_get_default_display ();
|
|
|
|
root_xwin = clutter_x11_get_root_window ();
|
|
|
|
|
|
|
|
if (!_clutter_backend_glx_get_fbconfig (backend_glx, &config))
|
|
|
|
{
|
|
|
|
g_set_error (error, CLUTTER_INIT_ERROR,
|
|
|
|
CLUTTER_INIT_ERROR_BACKEND,
|
2009-12-06 13:56:14 -05:00
|
|
|
"Unable to find suitable fbconfig for the GLX context");
|
2009-12-03 15:49:54 -05:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2009-12-06 13:56:14 -05:00
|
|
|
CLUTTER_NOTE (BACKEND, "Creating GLX Context (display: %p)", xdisplay);
|
2009-12-03 15:49:54 -05:00
|
|
|
|
|
|
|
backend_glx->gl_context = glXCreateNewContext (xdisplay,
|
|
|
|
config,
|
|
|
|
GLX_RGBA_TYPE,
|
|
|
|
NULL,
|
|
|
|
True);
|
2010-05-27 04:07:11 -04:00
|
|
|
if (backend_glx->gl_context == NULL)
|
2009-05-13 17:21:48 -04:00
|
|
|
{
|
2009-12-03 15:49:54 -05:00
|
|
|
g_set_error (error, CLUTTER_INIT_ERROR,
|
|
|
|
CLUTTER_INIT_ERROR_BACKEND,
|
|
|
|
"Unable to create suitable GL context");
|
|
|
|
return FALSE;
|
|
|
|
}
|
2009-05-13 17:21:48 -04:00
|
|
|
|
2009-12-03 15:49:54 -05:00
|
|
|
is_direct = glXIsDirect (xdisplay, backend_glx->gl_context);
|
2009-05-13 17:21:48 -04:00
|
|
|
|
2009-12-03 15:49:54 -05:00
|
|
|
CLUTTER_NOTE (GL, "Setting %s context",
|
|
|
|
is_direct ? "direct"
|
|
|
|
: "indirect");
|
|
|
|
_cogl_set_indirect_context (!is_direct);
|
|
|
|
|
2009-12-06 13:56:14 -05:00
|
|
|
/* COGL assumes that there is always a GL context selected; in order
|
|
|
|
* to make sure that a GLX context exists and is made current, we use
|
|
|
|
* a dummy, offscreen override-redirect window to which we can always
|
|
|
|
* fall back if no stage is available
|
2010-02-04 08:59:39 -05:00
|
|
|
*
|
|
|
|
* XXX - we need to do this dance because GLX does not allow creating
|
|
|
|
* a context and querying it for basic information (even the function
|
|
|
|
* pointers) unless it's made current to a real Drawable. it should be
|
|
|
|
* possible to avoid this in future releases of Mesa and X11, but right
|
|
|
|
* now this is the best solution available.
|
2009-12-03 15:49:54 -05:00
|
|
|
*/
|
|
|
|
xvisinfo = glXGetVisualFromFBConfig (xdisplay, config);
|
2010-05-27 04:07:11 -04:00
|
|
|
if (xvisinfo == NULL)
|
2009-12-03 15:49:54 -05:00
|
|
|
{
|
2009-12-06 13:56:14 -05:00
|
|
|
g_set_error (error, CLUTTER_INIT_ERROR,
|
|
|
|
CLUTTER_INIT_ERROR_BACKEND,
|
|
|
|
"Unable to retrieve the X11 visual");
|
2009-12-03 15:49:54 -05:00
|
|
|
return FALSE;
|
|
|
|
}
|
2009-12-01 11:18:39 -05:00
|
|
|
|
2009-12-03 15:49:54 -05:00
|
|
|
clutter_x11_trap_x_errors ();
|
2009-05-13 17:21:48 -04:00
|
|
|
|
2009-12-03 15:49:54 -05:00
|
|
|
attrs.override_redirect = True;
|
2010-02-04 11:28:29 -05:00
|
|
|
attrs.colormap = XCreateColormap (xdisplay,
|
|
|
|
root_xwin,
|
|
|
|
xvisinfo->visual,
|
|
|
|
AllocNone);
|
2010-03-08 09:37:36 -05:00
|
|
|
attrs.border_pixel = 0;
|
2010-02-04 11:28:29 -05:00
|
|
|
|
2009-12-03 15:49:54 -05:00
|
|
|
backend_glx->dummy_xwin = XCreateWindow (xdisplay, root_xwin,
|
|
|
|
-100, -100, 1, 1,
|
|
|
|
0,
|
|
|
|
xvisinfo->depth,
|
|
|
|
CopyFromParent,
|
|
|
|
xvisinfo->visual,
|
2010-03-08 09:37:36 -05:00
|
|
|
CWOverrideRedirect | CWColormap | CWBorderPixel,
|
2009-12-03 15:49:54 -05:00
|
|
|
&attrs);
|
2009-05-13 17:21:48 -04:00
|
|
|
|
2010-01-14 09:03:23 -05:00
|
|
|
/* 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)
|
|
|
|
{
|
|
|
|
backend_glx->dummy_glxwin = glXCreateWindow (backend_x11->xdpy,
|
|
|
|
config,
|
|
|
|
backend_glx->dummy_xwin,
|
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (backend_glx->dummy_glxwin)
|
|
|
|
dummy_drawable = backend_glx->dummy_glxwin;
|
|
|
|
else
|
|
|
|
dummy_drawable = backend_glx->dummy_xwin;
|
|
|
|
|
2009-12-06 13:56:14 -05:00
|
|
|
CLUTTER_NOTE (BACKEND, "Selecting dummy 0x%x for the GLX context",
|
2010-01-14 09:03:23 -05:00
|
|
|
(unsigned int) dummy_drawable);
|
2009-12-06 13:56:14 -05:00
|
|
|
|
2009-12-03 15:49:54 -05:00
|
|
|
glXMakeContextCurrent (xdisplay,
|
2010-01-14 09:03:23 -05:00
|
|
|
dummy_drawable,
|
|
|
|
dummy_drawable,
|
2009-12-03 15:49:54 -05:00
|
|
|
backend_glx->gl_context);
|
2009-05-13 17:21:48 -04:00
|
|
|
|
2010-02-04 08:56:33 -05:00
|
|
|
XFree (xvisinfo);
|
|
|
|
|
2009-12-03 15:49:54 -05:00
|
|
|
if (clutter_x11_untrap_x_errors ())
|
|
|
|
{
|
2009-12-06 13:56:14 -05:00
|
|
|
g_set_error (error, CLUTTER_INIT_ERROR,
|
|
|
|
CLUTTER_INIT_ERROR_BACKEND,
|
|
|
|
"Unable to select the newly created GLX context");
|
2009-12-03 15:49:54 -05:00
|
|
|
return FALSE;
|
2009-05-13 17:21:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2009-11-12 15:37:01 -05:00
|
|
|
/* TODO: remove this interface in favour of
|
|
|
|
* _clutter_stage_window_make_current () */
|
2007-05-28 14:49:34 -04:00
|
|
|
static void
|
2009-07-31 15:39:28 -04:00
|
|
|
clutter_backend_glx_ensure_context (ClutterBackend *backend,
|
2008-03-28 18:50:55 -04:00
|
|
|
ClutterStage *stage)
|
2007-05-28 14:49:34 -04:00
|
|
|
{
|
2009-08-21 07:05:52 -04:00
|
|
|
ClutterStageWindow *impl;
|
|
|
|
|
|
|
|
/* if there is no stage, the stage is being destroyed or it has no
|
|
|
|
* implementation attached to it then we clear the GL context
|
|
|
|
*/
|
|
|
|
if (stage == NULL ||
|
2010-07-21 11:10:46 -04:00
|
|
|
CLUTTER_ACTOR_IN_DESTRUCTION (stage) ||
|
2009-08-21 07:05:52 -04:00
|
|
|
((impl = _clutter_stage_get_window (stage)) == NULL))
|
2008-04-01 10:04:46 -04:00
|
|
|
{
|
2008-04-04 11:02:11 -04:00
|
|
|
ClutterBackendX11 *backend_x11;
|
|
|
|
|
|
|
|
backend_x11 = CLUTTER_BACKEND_X11 (backend);
|
2008-04-01 10:04:46 -04:00
|
|
|
CLUTTER_NOTE (MULTISTAGE, "Clearing all context");
|
2008-03-28 18:50:55 -04:00
|
|
|
|
2009-07-31 12:07:10 -04:00
|
|
|
glXMakeContextCurrent (backend_x11->xdpy, None, None, NULL);
|
2008-04-01 10:04:46 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-08-21 07:05:52 -04:00
|
|
|
ClutterBackendGLX *backend_glx;
|
2009-08-03 09:50:10 -04:00
|
|
|
ClutterBackendX11 *backend_x11;
|
2009-08-21 07:05:52 -04:00
|
|
|
ClutterStageGLX *stage_glx;
|
|
|
|
ClutterStageX11 *stage_x11;
|
2010-01-14 09:03:23 -05:00
|
|
|
GLXDrawable drawable;
|
2008-04-04 11:02:11 -04:00
|
|
|
|
|
|
|
g_assert (impl != NULL);
|
|
|
|
|
|
|
|
stage_glx = CLUTTER_STAGE_GLX (impl);
|
|
|
|
stage_x11 = CLUTTER_STAGE_X11 (impl);
|
|
|
|
backend_glx = CLUTTER_BACKEND_GLX (backend);
|
2009-08-03 09:50:10 -04:00
|
|
|
backend_x11 = CLUTTER_BACKEND_X11 (backend);
|
2008-04-01 10:04:46 -04:00
|
|
|
|
2010-01-14 09:03:23 -05:00
|
|
|
drawable = stage_glx->glxwin ? stage_glx->glxwin : stage_x11->xwin;
|
|
|
|
|
2009-12-03 12:13:44 -05:00
|
|
|
CLUTTER_NOTE (BACKEND,
|
|
|
|
"Setting context for stage of type %s, window: 0x%x",
|
|
|
|
G_OBJECT_TYPE_NAME (impl),
|
2010-01-14 09:03:23 -05:00
|
|
|
(unsigned int) drawable);
|
2009-12-03 12:13:44 -05:00
|
|
|
|
2008-04-04 13:26:26 -04:00
|
|
|
/* no GL context to set */
|
2010-05-27 04:07:11 -04:00
|
|
|
if (backend_glx->gl_context == NULL)
|
2008-04-04 13:26:26 -04:00
|
|
|
return;
|
2008-03-28 18:50:55 -04:00
|
|
|
|
2008-05-12 Emmanuele Bassi <ebassi@openedhand.com>
Rework the stage wrapper/implementation relation: remove
duplicated code and all the bookkeeping from the backends into
ClutterStage whenever possible, to reduce the amount of work a
backend must do (and possibly get wrong). Thanks to Tommi
Komulainen.
* clutter/clutter-main.c:
(clutter_init_with_args), (clutter_init): Realize the default
stage after creation. The default stage is special, because we
use it in the initialization sequence. This removes the burden
from the backends and reduces the things a backend can get
wrong.
* clutter/clutter-stage.c:
(clutter_stage_show): Make sure to realize the implementation if
it hasn't been realized yet.
(clutter_stage_realize): Set the REALIZED flag and call
clutter_stage_ensure_current() if the implementation was
successfully realized.
(clutter_stage_unrealized): Call clutter_stage_ensure_current()
on unrealize.
* clutter/glx/clutter-backend-glx.c:
(clutter_backend_glx_create_stage): Do not realize the stage anymore
when creating it, and let the normal realization sequence take
place.
(clutter_backend_glx_ensure_context): Trap for X11 errors.
* clutter/glx/clutter-stage-glx.c:
(clutter_stage_glx_realize): Chain up to the X11 implementation
so that we can set up the window state (title, cursor visibility)
when we actually have a X window. Also, do not call
clutter_stage_ensure_current(), and rely on the wrapper to do
it for us. This means we can drop setting the REALIZED flag on
the wrapper.
(clutter_stage_glx_unrealize): Do not call
clutter_stage_ensure_current() ourselves, and rely on the wrapper
to do it for us.
* clutter/x11/clutter-stage-x11.c:
(set_wm_title), (set_cursor_visible): Move the WM title and
cursor visibility code inside their own functions.
(clutter_stage_x11_realize): Set the window title and whether the
cursor is visible or not after realizing the stage.
(clutter_stage_x11_set_cursor_visible),
(clutter_stage_x11_set_title): Call set_wm_title() and
set_cursor_visible().
(clutter_stage_x11_finalize): Free the title string.
* clutter/x11/clutter-stage-x11.h: Save more of the stage state,
so that we can set it even when the stage hasn't been realized
yet.
* clutter/eglnative/clutter-backend-egl.c:
(clutter_backend_egl_create_stage):
* clutter/eglnative/clutter-stage-egl.c:
(clutter_stage_egl_unrealize),
(clutter_stage_egl_realize): Update the eglnative backend.
* clutter/eglx/clutter-backend-egl.c:
(clutter_backend_egl_ensure_context),
(clutter_backend_egl_create_stage):
* clutter/eglx/clutter-stage-egl.c:
(clutter_stage_egl_unrealize),
(clutter_stage_egl_realize): Update the eglx backend.
* clutter/sdl/clutter-backend-sdl.c:
(clutter_backend_sdl_create_stage):
* clutter/sdl/clutter-stage-sdl.c:
(clutter_stage_sdl_realize): Update the sdl backend.
* clutter/fruity/clutter-backend-fruity.c:
(clutter_backend_fruity_create_stage):
* clutter/sdl/clutter-stage-fruity.c:
(clutter_stage_fruity_realize): Update the fruity backend.
* tests/test-multistage.c (on_button_press): Bail out if
clutter_stage_new() returns NULL.
* HACKING.backends: Update backend writing documentation.
2008-05-12 11:26:37 -04:00
|
|
|
clutter_x11_trap_x_errors ();
|
|
|
|
|
2008-04-04 11:02:11 -04:00
|
|
|
/* we might get here inside the final dispose cycle, so we
|
|
|
|
* need to handle this gracefully
|
|
|
|
*/
|
2010-01-14 09:03:23 -05:00
|
|
|
if (drawable == None)
|
2008-04-04 11:02:11 -04:00
|
|
|
{
|
2010-01-14 09:03:23 -05:00
|
|
|
GLXDrawable dummy_drawable;
|
|
|
|
|
2009-12-03 12:13:44 -05:00
|
|
|
CLUTTER_NOTE (BACKEND,
|
2008-04-04 11:02:11 -04:00
|
|
|
"Received a stale stage, clearing all context");
|
2008-04-01 10:04:46 -04:00
|
|
|
|
2010-01-14 09:03:23 -05:00
|
|
|
if (backend_glx->dummy_glxwin)
|
|
|
|
dummy_drawable = backend_glx->dummy_glxwin;
|
|
|
|
else
|
|
|
|
dummy_drawable = backend_glx->dummy_xwin;
|
|
|
|
|
|
|
|
if (dummy_drawable == None)
|
|
|
|
glXMakeContextCurrent (backend_x11->xdpy, None, None, NULL);
|
|
|
|
else
|
2009-12-03 15:49:54 -05:00
|
|
|
{
|
|
|
|
glXMakeContextCurrent (backend_x11->xdpy,
|
2010-01-14 09:03:23 -05:00
|
|
|
dummy_drawable,
|
|
|
|
dummy_drawable,
|
2009-12-03 15:49:54 -05:00
|
|
|
backend_glx->gl_context);
|
|
|
|
}
|
2008-04-04 11:02:11 -04:00
|
|
|
}
|
|
|
|
else
|
2008-04-04 13:26:26 -04:00
|
|
|
{
|
|
|
|
CLUTTER_NOTE (BACKEND,
|
2009-07-31 12:07:10 -04:00
|
|
|
"MakeContextCurrent dpy: %p, window: 0x%x (%s), context: %p",
|
2009-08-03 09:50:10 -04:00
|
|
|
backend_x11->xdpy,
|
2010-01-14 09:03:23 -05:00
|
|
|
(unsigned int) drawable,
|
2008-04-04 13:26:26 -04:00
|
|
|
stage_x11->is_foreign_xwin ? "foreign" : "native",
|
2008-04-04 11:02:11 -04:00
|
|
|
backend_glx->gl_context);
|
2008-04-04 13:26:26 -04:00
|
|
|
|
2009-08-03 09:50:10 -04:00
|
|
|
glXMakeContextCurrent (backend_x11->xdpy,
|
2010-01-14 09:03:23 -05:00
|
|
|
drawable,
|
|
|
|
drawable,
|
2009-07-31 12:07:10 -04:00
|
|
|
backend_glx->gl_context);
|
2010-03-21 08:12:58 -04:00
|
|
|
/*
|
|
|
|
* In case we are using GLX_SGI_swap_control for vblank syncing we need call
|
|
|
|
* glXSwapIntervalSGI here to make sure that it affects the current drawable.
|
|
|
|
*/
|
|
|
|
if (backend_glx->vblank_type == CLUTTER_VBLANK_GLX_SWAP && backend_glx->swap_interval != NULL)
|
|
|
|
backend_glx->swap_interval (1);
|
2008-04-04 13:26:26 -04:00
|
|
|
}
|
2008-05-12 Emmanuele Bassi <ebassi@openedhand.com>
Rework the stage wrapper/implementation relation: remove
duplicated code and all the bookkeeping from the backends into
ClutterStage whenever possible, to reduce the amount of work a
backend must do (and possibly get wrong). Thanks to Tommi
Komulainen.
* clutter/clutter-main.c:
(clutter_init_with_args), (clutter_init): Realize the default
stage after creation. The default stage is special, because we
use it in the initialization sequence. This removes the burden
from the backends and reduces the things a backend can get
wrong.
* clutter/clutter-stage.c:
(clutter_stage_show): Make sure to realize the implementation if
it hasn't been realized yet.
(clutter_stage_realize): Set the REALIZED flag and call
clutter_stage_ensure_current() if the implementation was
successfully realized.
(clutter_stage_unrealized): Call clutter_stage_ensure_current()
on unrealize.
* clutter/glx/clutter-backend-glx.c:
(clutter_backend_glx_create_stage): Do not realize the stage anymore
when creating it, and let the normal realization sequence take
place.
(clutter_backend_glx_ensure_context): Trap for X11 errors.
* clutter/glx/clutter-stage-glx.c:
(clutter_stage_glx_realize): Chain up to the X11 implementation
so that we can set up the window state (title, cursor visibility)
when we actually have a X window. Also, do not call
clutter_stage_ensure_current(), and rely on the wrapper to do
it for us. This means we can drop setting the REALIZED flag on
the wrapper.
(clutter_stage_glx_unrealize): Do not call
clutter_stage_ensure_current() ourselves, and rely on the wrapper
to do it for us.
* clutter/x11/clutter-stage-x11.c:
(set_wm_title), (set_cursor_visible): Move the WM title and
cursor visibility code inside their own functions.
(clutter_stage_x11_realize): Set the window title and whether the
cursor is visible or not after realizing the stage.
(clutter_stage_x11_set_cursor_visible),
(clutter_stage_x11_set_title): Call set_wm_title() and
set_cursor_visible().
(clutter_stage_x11_finalize): Free the title string.
* clutter/x11/clutter-stage-x11.h: Save more of the stage state,
so that we can set it even when the stage hasn't been realized
yet.
* clutter/eglnative/clutter-backend-egl.c:
(clutter_backend_egl_create_stage):
* clutter/eglnative/clutter-stage-egl.c:
(clutter_stage_egl_unrealize),
(clutter_stage_egl_realize): Update the eglnative backend.
* clutter/eglx/clutter-backend-egl.c:
(clutter_backend_egl_ensure_context),
(clutter_backend_egl_create_stage):
* clutter/eglx/clutter-stage-egl.c:
(clutter_stage_egl_unrealize),
(clutter_stage_egl_realize): Update the eglx backend.
* clutter/sdl/clutter-backend-sdl.c:
(clutter_backend_sdl_create_stage):
* clutter/sdl/clutter-stage-sdl.c:
(clutter_stage_sdl_realize): Update the sdl backend.
* clutter/fruity/clutter-backend-fruity.c:
(clutter_backend_fruity_create_stage):
* clutter/sdl/clutter-stage-fruity.c:
(clutter_stage_fruity_realize): Update the fruity backend.
* tests/test-multistage.c (on_button_press): Bail out if
clutter_stage_new() returns NULL.
* HACKING.backends: Update backend writing documentation.
2008-05-12 11:26:37 -04:00
|
|
|
|
|
|
|
if (clutter_x11_untrap_x_errors ())
|
|
|
|
g_critical ("Unable to make the stage window 0x%x the current "
|
|
|
|
"GLX drawable",
|
2010-01-14 09:03:23 -05:00
|
|
|
(unsigned int) drawable);
|
2008-04-01 10:04:46 -04:00
|
|
|
}
|
2008-03-28 18:50:55 -04:00
|
|
|
}
|
|
|
|
|
2009-08-13 07:34:07 -04:00
|
|
|
static ClutterStageWindow *
|
2008-03-28 18:50:55 -04:00
|
|
|
clutter_backend_glx_create_stage (ClutterBackend *backend,
|
2008-04-04 11:02:11 -04:00
|
|
|
ClutterStage *wrapper,
|
2008-03-28 18:50:55 -04:00
|
|
|
GError **error)
|
2007-11-15 09:45:27 -05:00
|
|
|
{
|
|
|
|
ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend);
|
event/x11: Rework the way we translate X11 events
This is a lump commit that is fairly difficult to break down without
either breaking bisecting or breaking the test cases.
The new design for handling X11 event translation works this way:
- ClutterBackend::translate_event() has been added as the central
point used by a ClutterBackend implementation to translate a
native event into a ClutterEvent;
- ClutterEventTranslator is a private interface that should be
implemented by backend-specific objects, like stage
implementations and ClutterDeviceManager sub-classes, and
allows dealing with class-specific event translation;
- ClutterStageX11 implements EventTranslator, and deals with the
stage-relative X11 events coming from the X11 event source;
- ClutterStageGLX overrides EventTranslator, in order to
deal with the INTEL_GLX_swap_event extension, and it chains up
to the X11 default implementation;
- ClutterDeviceManagerX11 has been split into two separate classes,
one that deals with core and (optionally) XI1 events, and the
other that deals with XI2 events; the selection is done at run-time,
since the core+XI1 and XI2 mechanisms are mutually exclusive.
All the other backends we officially support still use their own
custom event source and translation function, but the end goal is to
migrate them to the translate_event() virtual function, and have the
event source be a shared part of Clutter core.
2011-01-04 07:32:04 -05:00
|
|
|
ClutterEventTranslator *translator;
|
2009-08-13 07:34:07 -04:00
|
|
|
ClutterStageWindow *stage_window;
|
|
|
|
ClutterStageX11 *stage_x11;
|
2007-11-15 09:45:27 -05:00
|
|
|
|
2009-08-13 07:34:07 -04:00
|
|
|
stage_window = g_object_new (CLUTTER_TYPE_STAGE_GLX, NULL);
|
2007-11-15 09:45:27 -05:00
|
|
|
|
2008-03-28 18:50:55 -04:00
|
|
|
/* copy backend data into the stage */
|
2009-08-13 07:34:07 -04:00
|
|
|
stage_x11 = CLUTTER_STAGE_X11 (stage_window);
|
2008-04-04 11:02:11 -04:00
|
|
|
stage_x11->wrapper = wrapper;
|
2011-01-26 06:58:08 -05:00
|
|
|
stage_x11->backend = backend_x11;
|
2008-04-04 11:02:11 -04:00
|
|
|
|
event/x11: Rework the way we translate X11 events
This is a lump commit that is fairly difficult to break down without
either breaking bisecting or breaking the test cases.
The new design for handling X11 event translation works this way:
- ClutterBackend::translate_event() has been added as the central
point used by a ClutterBackend implementation to translate a
native event into a ClutterEvent;
- ClutterEventTranslator is a private interface that should be
implemented by backend-specific objects, like stage
implementations and ClutterDeviceManager sub-classes, and
allows dealing with class-specific event translation;
- ClutterStageX11 implements EventTranslator, and deals with the
stage-relative X11 events coming from the X11 event source;
- ClutterStageGLX overrides EventTranslator, in order to
deal with the INTEL_GLX_swap_event extension, and it chains up
to the X11 default implementation;
- ClutterDeviceManagerX11 has been split into two separate classes,
one that deals with core and (optionally) XI1 events, and the
other that deals with XI2 events; the selection is done at run-time,
since the core+XI1 and XI2 mechanisms are mutually exclusive.
All the other backends we officially support still use their own
custom event source and translation function, but the end goal is to
migrate them to the translate_event() virtual function, and have the
event source be a shared part of Clutter core.
2011-01-04 07:32:04 -05:00
|
|
|
translator = CLUTTER_EVENT_TRANSLATOR (stage_x11);
|
2011-02-09 07:20:56 -05:00
|
|
|
_clutter_backend_add_event_translator (backend, translator);
|
event/x11: Rework the way we translate X11 events
This is a lump commit that is fairly difficult to break down without
either breaking bisecting or breaking the test cases.
The new design for handling X11 event translation works this way:
- ClutterBackend::translate_event() has been added as the central
point used by a ClutterBackend implementation to translate a
native event into a ClutterEvent;
- ClutterEventTranslator is a private interface that should be
implemented by backend-specific objects, like stage
implementations and ClutterDeviceManager sub-classes, and
allows dealing with class-specific event translation;
- ClutterStageX11 implements EventTranslator, and deals with the
stage-relative X11 events coming from the X11 event source;
- ClutterStageGLX overrides EventTranslator, in order to
deal with the INTEL_GLX_swap_event extension, and it chains up
to the X11 default implementation;
- ClutterDeviceManagerX11 has been split into two separate classes,
one that deals with core and (optionally) XI1 events, and the
other that deals with XI2 events; the selection is done at run-time,
since the core+XI1 and XI2 mechanisms are mutually exclusive.
All the other backends we officially support still use their own
custom event source and translation function, but the end goal is to
migrate them to the translate_event() virtual function, and have the
event source be a shared part of Clutter core.
2011-01-04 07:32:04 -05:00
|
|
|
|
2009-05-08 12:17:48 -04:00
|
|
|
CLUTTER_NOTE (BACKEND,
|
|
|
|
"GLX stage created[%p] (dpy:%p, screen:%d, root:%u, wrap:%p)",
|
2009-08-13 07:34:07 -04:00
|
|
|
stage_window,
|
2009-08-03 09:50:10 -04:00
|
|
|
backend_x11->xdpy,
|
|
|
|
backend_x11->xscreen_num,
|
|
|
|
(unsigned int) backend_x11->xwin_root,
|
2009-05-08 12:17:48 -04:00
|
|
|
wrapper);
|
2007-11-15 09:45:27 -05:00
|
|
|
|
2009-08-13 07:34:07 -04:00
|
|
|
return stage_window;
|
2007-05-28 14:49:34 -04:00
|
|
|
}
|
|
|
|
|
2007-03-22 14:21:59 -04:00
|
|
|
static void
|
2011-01-21 05:49:12 -05:00
|
|
|
clutter_backend_glx_class_init (ClutterBackendGLXClass *klass)
|
2007-03-22 14:21:59 -04:00
|
|
|
{
|
|
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
|
|
ClutterBackendClass *backend_class = CLUTTER_BACKEND_CLASS (klass);
|
2009-05-13 16:49:45 -04:00
|
|
|
ClutterBackendX11Class *backendx11_class = CLUTTER_BACKEND_X11_CLASS (klass);
|
2007-03-22 14:21:59 -04:00
|
|
|
|
|
|
|
gobject_class->constructor = clutter_backend_glx_constructor;
|
2008-03-28 18:50:55 -04:00
|
|
|
gobject_class->dispose = clutter_backend_glx_dispose;
|
|
|
|
gobject_class->finalize = clutter_backend_glx_finalize;
|
2007-03-22 14:21:59 -04:00
|
|
|
|
2008-04-04 11:02:11 -04:00
|
|
|
backend_class->pre_parse = clutter_backend_glx_pre_parse;
|
|
|
|
backend_class->post_parse = clutter_backend_glx_post_parse;
|
|
|
|
backend_class->create_stage = clutter_backend_glx_create_stage;
|
|
|
|
backend_class->add_options = clutter_backend_glx_add_options;
|
|
|
|
backend_class->get_features = clutter_backend_glx_get_features;
|
2009-05-13 17:21:48 -04:00
|
|
|
backend_class->create_context = clutter_backend_glx_create_context;
|
2008-03-28 18:50:55 -04:00
|
|
|
backend_class->ensure_context = clutter_backend_glx_ensure_context;
|
2009-05-13 16:49:45 -04:00
|
|
|
|
|
|
|
backendx11_class->get_visual_info = clutter_backend_glx_get_visual_info;
|
2007-03-22 14:21:59 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-01-21 05:49:12 -05:00
|
|
|
clutter_backend_glx_init (ClutterBackendGLX *backend_glx)
|
2007-03-22 14:21:59 -04:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/* every backend must implement this function */
|
|
|
|
GType
|
|
|
|
_clutter_backend_impl_get_type (void)
|
|
|
|
{
|
2010-08-13 10:48:30 -04:00
|
|
|
return _clutter_backend_glx_get_type ();
|
2007-03-22 14:21:59 -04:00
|
|
|
}
|