static CoglDisplay * clutter_backend_wayland_get_display (ClutterBackend *backend, CoglRenderer *renderer, CoglSwapChain *swap_chain, GError **error) { CoglOnscreenTemplate *onscreen_template = NULL; CoglDisplay *display; onscreen_template = cogl_onscreen_template_new (swap_chain); /* XXX: I have some doubts that this is a good design. * Conceptually should we be able to check an onscreen_template * without more details about the CoglDisplay configuration? */ if (!cogl_renderer_check_onscreen_template (renderer, onscreen_template, error)) goto error; display = cogl_display_new (renderer, onscreen_template); return display; error: if (onscreen_template) cogl_object_unref (onscreen_template); return NULL; }
static CoglDisplay * clutter_backend_cex100_get_display (ClutterBackend *backend, CoglRenderer *renderer, CoglSwapChain *swap_chain, GError **error) { CoglOnscreenTemplate *onscreen_template = NULL; CoglDisplay *display; swap_chain = cogl_swap_chain_new (); #if defined(COGL_HAS_GDL_SUPPORT) cogl_swap_chain_set_length (swap_chain, gdl_n_buffers); #endif onscreen_template = cogl_onscreen_template_new (swap_chain); /* XXX: I have some doubts that this is a good design. * Conceptually should we be able to check an onscreen_template * without more details about the CoglDisplay configuration? */ if (!cogl_renderer_check_onscreen_template (renderer, onscreen_template, error)) goto error; display = cogl_display_new (renderer, onscreen_template); #if defined(COGL_HAS_GDL_SUPPORT) cogl_gdl_display_set_plane (cogl_display, gdl_plane); #endif return display; }
static gboolean clutter_backend_win32_create_context (ClutterBackend *backend, GError **error) { CoglSwapChain *swap_chain; CoglOnscreenTemplate *onscreen_template; if (backend->cogl_context) return TRUE; backend->cogl_renderer = cogl_renderer_new (); if (!cogl_renderer_connect (backend->cogl_renderer, error)) goto error; swap_chain = cogl_swap_chain_new (); onscreen_template = cogl_onscreen_template_new (swap_chain); cogl_object_unref (swap_chain); if (!cogl_renderer_check_onscreen_template (backend->cogl_renderer, onscreen_template, error)) goto error; backend->cogl_display = cogl_display_new (backend->cogl_renderer, onscreen_template); cogl_object_unref (backend->cogl_renderer); cogl_object_unref (onscreen_template); if (!cogl_display_setup (backend->cogl_display, error)) goto error; backend->cogl_context = cogl_context_new (backend->cogl_display, error); if (!backend->cogl_context) goto error; return TRUE; error: if (backend->cogl_display) { cogl_object_unref (backend->cogl_display); backend->cogl_display = NULL; } if (onscreen_template) cogl_object_unref (onscreen_template); if (swap_chain) cogl_object_unref (swap_chain); if (backend->cogl_renderer) { cogl_object_unref (backend->cogl_renderer); backend->cogl_renderer = NULL; } return FALSE; }
static gboolean check_onscreen_template (CoglRenderer *renderer, CoglSwapChain *swap_chain, CoglOnscreenTemplate *onscreen_template, CoglBool enable_argb, CoglBool enable_stereo, GError **error) { GError *internal_error = NULL; cogl_swap_chain_set_has_alpha (swap_chain, enable_argb); cogl_onscreen_template_set_stereo_enabled (onscreen_template, clutter_enable_stereo); /* cogl_renderer_check_onscreen_template() is actually just a * shorthand for creating a CoglDisplay, and calling * cogl_display_setup() on it, then throwing the display away. If we * could just return that display, then it would be more efficient * not to use cogl_renderer_check_onscreen_template(). However, the * backend API requires that we return an CoglDisplay that has not * yet been setup, so one way or the other we'll have to discard the * first display and make a new fresh one. */ if (cogl_renderer_check_onscreen_template (renderer, onscreen_template, &internal_error)) { clutter_enable_argb = enable_argb; clutter_enable_stereo = enable_stereo; return TRUE; } else { if (enable_argb || enable_stereo) /* More possibilities to try */ CLUTTER_NOTE (BACKEND, "Creation of a CoglDisplay with alpha=%s, stereo=%s failed: %s", enable_argb ? "enabled" : "disabled", enable_stereo ? "enabled" : "disabled", internal_error != NULL ? internal_error->message : "Unknown reason"); else g_set_error_literal (error, CLUTTER_INIT_ERROR, CLUTTER_INIT_ERROR_BACKEND, internal_error != NULL ? internal_error->message : "Creation of a CoglDisplay failed"); g_clear_error (&internal_error); return FALSE; } }
static CoglDisplay * clutter_backend_gdk_get_display (ClutterBackend *backend, CoglRenderer *renderer, CoglSwapChain *swap_chain, GError **error) { ClutterBackendGdk *backend_gdk = CLUTTER_BACKEND_GDK (backend); CoglOnscreenTemplate *onscreen_template; GError *internal_error = NULL; CoglDisplay *display; gboolean has_rgba_visual; gboolean res; has_rgba_visual = gdk_screen_get_rgba_visual (backend_gdk->screen) == NULL; CLUTTER_NOTE (BACKEND, "Alpha on Cogl swap chain: %s", has_rgba_visual ? "enabled" : "disabled"); cogl_swap_chain_set_has_alpha (swap_chain, has_rgba_visual); onscreen_template = cogl_onscreen_template_new (swap_chain); res = cogl_renderer_check_onscreen_template (renderer, onscreen_template, &internal_error); if (!res && has_rgba_visual) { CLUTTER_NOTE (BACKEND, "Creation of a context with a ARGB visual failed: %s", internal_error != NULL ? internal_error->message : "Unknown reason"); g_clear_error (&internal_error); /* It's possible that the current renderer doesn't support transparency * in a swap_chain so lets see if we can fallback to not having any * transparency... * * XXX: It might be nice to have a CoglRenderer feature we could * explicitly check for ahead of time. */ cogl_swap_chain_set_has_alpha (swap_chain, FALSE); res = cogl_renderer_check_onscreen_template (renderer, onscreen_template, &internal_error); } if (!res) { g_set_error_literal (error, CLUTTER_INIT_ERROR, CLUTTER_INIT_ERROR_BACKEND, internal_error->message); g_error_free (internal_error); cogl_object_unref (onscreen_template); return NULL; } display = cogl_display_new (renderer, onscreen_template); cogl_object_unref (onscreen_template); return display; }
static gboolean clutter_backend_real_create_context (ClutterBackend *backend, GError **error) { ClutterBackendClass *klass; CoglSwapChain *swap_chain; GError *internal_error; if (backend->cogl_context != NULL) return TRUE; klass = CLUTTER_BACKEND_GET_CLASS (backend); swap_chain = NULL; internal_error = NULL; CLUTTER_NOTE (BACKEND, "Creating Cogl renderer"); if (klass->get_renderer != NULL) backend->cogl_renderer = klass->get_renderer (backend, &internal_error); else backend->cogl_renderer = cogl_renderer_new (); if (backend->cogl_renderer == NULL) goto error; #ifdef HAVE_CLUTTER_WAYLAND_COMPOSITOR /* If the application is trying to act as a Wayland compositor then it needs to have an EGL-based renderer backend */ if (_wayland_compositor_display) cogl_renderer_add_constraint (backend->cogl_renderer, COGL_RENDERER_CONSTRAINT_USES_EGL); #endif CLUTTER_NOTE (BACKEND, "Connecting the renderer"); if (!cogl_renderer_connect (backend->cogl_renderer, &internal_error)) goto error; CLUTTER_NOTE (BACKEND, "Creating Cogl swap chain"); swap_chain = cogl_swap_chain_new (); CLUTTER_NOTE (BACKEND, "Creating Cogl display"); if (klass->get_display != NULL) { backend->cogl_display = klass->get_display (backend, backend->cogl_renderer, swap_chain, &internal_error); } else { CoglOnscreenTemplate *tmpl; gboolean res; tmpl = cogl_onscreen_template_new (swap_chain); /* XXX: I have some doubts that this is a good design. * * Conceptually should we be able to check an onscreen_template * without more details about the CoglDisplay configuration? */ res = cogl_renderer_check_onscreen_template (backend->cogl_renderer, tmpl, &internal_error); if (!res) goto error; backend->cogl_display = cogl_display_new (backend->cogl_renderer, tmpl); /* the display owns the template */ cogl_object_unref (tmpl); } if (backend->cogl_display == NULL) goto error; #ifdef HAVE_CLUTTER_WAYLAND_COMPOSITOR cogl_wayland_display_set_compositor_display (backend->cogl_display, _wayland_compositor_display); #endif CLUTTER_NOTE (BACKEND, "Setting up the display"); if (!cogl_display_setup (backend->cogl_display, &internal_error)) goto error; CLUTTER_NOTE (BACKEND, "Creating the Cogl context"); backend->cogl_context = cogl_context_new (backend->cogl_display, &internal_error); if (backend->cogl_context == NULL) goto error; backend->cogl_source = cogl_glib_source_new (backend->cogl_context, G_PRIORITY_DEFAULT); g_source_attach (backend->cogl_source, NULL); /* the display owns the renderer and the swap chain */ cogl_object_unref (backend->cogl_renderer); cogl_object_unref (swap_chain); return TRUE; error: if (backend->cogl_display != NULL) { cogl_object_unref (backend->cogl_display); backend->cogl_display = NULL; } if (backend->cogl_renderer != NULL) { cogl_object_unref (backend->cogl_renderer); backend->cogl_renderer = NULL; } if (swap_chain != NULL) cogl_object_unref (swap_chain); if (internal_error != NULL) g_propagate_error (error, internal_error); else g_set_error_literal (error, CLUTTER_INIT_ERROR, CLUTTER_INIT_ERROR_BACKEND, _("Unable to initialize the Clutter backend")); return FALSE; }