static void
_cogl_winsys_onscreen_bind (CoglOnscreen *onscreen)
{
CoglFramebuffer *fb = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = fb->context;
CoglContextSdl2 *sdl_context = context->winsys;
CoglDisplaySdl2 *sdl_display = context->display->winsys;
CoglOnscreenSdl2 *sdl_onscreen = onscreen->winsys;
if (sdl_context->current_window == sdl_onscreen->window)
return;
SDL_GL_MakeCurrent (sdl_onscreen->window, sdl_display->context);
sdl_context->current_window = sdl_onscreen->window;
/* It looks like SDL just directly calls a glXSwapInterval function
* when this is called. This may be provided by either the EXT
* extension, the SGI extension or the Mesa extension. The SGI
* extension is per context so we can't just do this once when the
* framebuffer is allocated. See the comments in the GLX winsys for
* more info. */
if (COGL_FLAGS_GET (context->winsys_features,
COGL_WINSYS_FEATURE_SWAP_REGION_THROTTLE))
{
CoglFramebuffer *fb = COGL_FRAMEBUFFER (onscreen);
SDL_GL_SetSwapInterval (fb->config.swap_throttled ? 1 : 0);
}
}
static void
handle_event (Data *data, SDL_Event *event)
{
switch (event->type)
{
case SDL_VIDEOEXPOSE:
data->redraw_queued = TRUE;
break;
case SDL_MOUSEMOTION:
{
int width =
cogl_framebuffer_get_width (COGL_FRAMEBUFFER (data->fb));
int height =
cogl_framebuffer_get_height (COGL_FRAMEBUFFER (data->fb));
data->center_x = event->motion.x * 2.0f / width - 1.0f;
data->center_y = event->motion.y * 2.0f / height - 1.0f;
data->redraw_queued = TRUE;
}
break;
case SDL_QUIT:
data->quit = TRUE;
break;
}
}
static void
_cogl_winsys_onscreen_deinit (CoglOnscreen *onscreen)
{
CoglOnscreenSdl2 *sdl_onscreen = onscreen->winsys;
if (sdl_onscreen->window != NULL)
{
CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context;
CoglContextSdl2 *sdl_context = context->winsys;
if (sdl_context->current_window == sdl_onscreen->window)
{
CoglDisplaySdl2 *sdl_display = context->display->winsys;
/* SDL explicitly unbinds the context when the currently
* bound window is destroyed. Cogl always needs a context
* bound so that for example it can create texture resources
* at any time even without flushing a framebuffer.
* Therefore we'll bind the dummy window. */
SDL_GL_MakeCurrent (sdl_display->dummy_window,
sdl_display->context);
sdl_context->current_window = sdl_display->dummy_window;
}
SDL_DestroyWindow (sdl_onscreen->window);
sdl_onscreen->window = NULL;
}
g_slice_free (CoglOnscreenSdl2, sdl_onscreen);
onscreen->winsys = NULL;
}
static CoglFramebuffer *
clutter_stage_win32_get_active_framebuffer (ClutterStageWindow *stage_window)
{
ClutterStageWin32 *stage_win32 = CLUTTER_STAGE_WIN32 (stage_window);
return COGL_FRAMEBUFFER (stage_win32->onscreen);
}
static CoglBool
_cogl_winsys_egl_onscreen_init (CoglOnscreen *onscreen,
EGLConfig egl_config,
CoglError **error)
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglDisplay *display = context->display;
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayGDL *gdl_display = egl_display->platform;
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
if (gdl_display->have_onscreen)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"EGL platform only supports a single onscreen window");
return FALSE;
}
egl_onscreen->egl_surface = egl_display->egl_surface;
_cogl_framebuffer_winsys_update_size (framebuffer,
gdl_display->egl_surface_width,
gdl_display->egl_surface_height);
gdl_display->have_onscreen = TRUE;
return TRUE;
}
void
test_backface_culling (void)
{
TestState state;
CoglTexture *tex;
state.width = cogl_framebuffer_get_width (test_fb);
state.height = cogl_framebuffer_get_height (test_fb);
state.offscreen = NULL;
state.texture = make_texture ();
tex = cogl_texture_new_with_size (state.width, state.height,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_ANY); /* internal fmt */
state.offscreen = COGL_FRAMEBUFFER (cogl_offscreen_new_to_texture (tex));
state.offscreen_tex = tex;
paint (&state);
cogl_object_unref (state.offscreen);
cogl_object_unref (state.offscreen_tex);
cogl_object_unref (state.texture);
if (cogl_test_verbose ())
g_print ("OK\n");
}
void
test_color_mask (void)
{
TestState state;
int i;
state.width = cogl_framebuffer_get_width (test_fb);
state.height = cogl_framebuffer_get_height (test_fb);
for (i = 0; i < NUM_FBOS; i++)
{
state.tex[i] = test_utils_texture_new_with_size (test_ctx, 128, 128,
TEST_UTILS_TEXTURE_NO_ATLAS,
COGL_PIXEL_FORMAT_RGB_888);
state.fbo[i] = COGL_FRAMEBUFFER (
cogl_offscreen_new_to_texture (state.tex[i]));
/* Clear the texture color bits */
cogl_framebuffer_clear4f (state.fbo[i],
COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
cogl_framebuffer_set_color_mask (state.fbo[i],
i == 0 ? COGL_COLOR_MASK_RED :
i == 1 ? COGL_COLOR_MASK_GREEN :
COGL_COLOR_MASK_BLUE);
}
paint (&state);
if (cogl_test_verbose ())
g_print ("OK\n");
}
static void
_cogl_winsys_onscreen_deinit (CoglOnscreen *onscreen)
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
/* If we never successfully allocated then there's nothing to do */
if (egl_onscreen == NULL)
return;
if (egl_onscreen->egl_surface != EGL_NO_SURFACE)
{
if (eglDestroySurface (egl_renderer->edpy, egl_onscreen->egl_surface)
== EGL_FALSE)
g_warning ("Failed to destroy EGL surface");
egl_onscreen->egl_surface = EGL_NO_SURFACE;
}
if (egl_renderer->platform_vtable->onscreen_deinit)
egl_renderer->platform_vtable->onscreen_deinit (onscreen);
g_slice_free (CoglOnscreenEGL, onscreen->winsys);
onscreen->winsys = NULL;
}
static void
_cogl_winsys_onscreen_bind (CoglOnscreen *onscreen)
{
CoglFramebuffer *fb = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = fb->context;
CoglDisplayEGL *egl_display = context->display->winsys;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglContextEGL *egl_context = context->winsys;
if (egl_context->current_surface == egl_onscreen->egl_surface)
return;
eglMakeCurrent (egl_renderer->edpy,
egl_onscreen->egl_surface,
egl_onscreen->egl_surface,
egl_display->egl_context);
egl_context->current_surface = egl_onscreen->egl_surface;
if (fb->config.swap_throttled)
eglSwapInterval (egl_renderer->edpy, 1);
else
eglSwapInterval (egl_renderer->edpy, 0);
}
static void
flush_pending_resize (CoglOnscreen *onscreen)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
if (wayland_onscreen->has_pending)
{
wl_egl_window_resize (wayland_onscreen->wayland_egl_native_window,
wayland_onscreen->pending_width,
wayland_onscreen->pending_height,
wayland_onscreen->pending_dx,
wayland_onscreen->pending_dy);
_cogl_framebuffer_winsys_update_size (COGL_FRAMEBUFFER (onscreen),
wayland_onscreen->pending_width,
wayland_onscreen->pending_height);
_cogl_onscreen_queue_full_dirty (onscreen);
wayland_onscreen->pending_dx = 0;
wayland_onscreen->pending_dy = 0;
wayland_onscreen->has_pending = FALSE;
}
}
static void
_cogl_winsys_egl_onscreen_deinit (CoglOnscreen *onscreen)
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglRenderer *renderer = context->display->renderer;
CoglXlibRenderer *xlib_renderer =
_cogl_xlib_renderer_get_data (renderer);
CoglXlibTrapState old_state;
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenXlib *xlib_onscreen = egl_onscreen->platform;
_cogl_xlib_renderer_trap_errors (renderer, &old_state);
if (!xlib_onscreen->is_foreign_xwin && xlib_onscreen->xwin != None)
{
XDestroyWindow (xlib_renderer->xdpy, xlib_onscreen->xwin);
xlib_onscreen->xwin = None;
}
else
xlib_onscreen->xwin = None;
XSync (xlib_renderer->xdpy, False);
if (_cogl_xlib_renderer_untrap_errors (renderer,
&old_state) != Success)
g_warning ("X Error while destroying X window");
g_slice_free (CoglOnscreenXlib, xlib_onscreen);
}
static CoglBool
bind_onscreen_with_context (CoglOnscreen *onscreen,
EGLContext egl_context)
{
CoglFramebuffer *fb = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = fb->context;
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglBool status = _cogl_winsys_egl_make_current (context->display,
egl_onscreen->egl_surface,
egl_onscreen->egl_surface,
egl_context);
if (status)
{
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
if (fb->config.swap_throttled)
eglSwapInterval (egl_renderer->edpy, 1);
else
eglSwapInterval (egl_renderer->edpy, 0);
}
return status;
}
void
cogl_wayland_onscreen_resize (CoglOnscreen *onscreen,
int width,
int height,
int offset_x,
int offset_y)
{
CoglFramebuffer *fb;
fb = COGL_FRAMEBUFFER (onscreen);
if (fb->allocated)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
if (cogl_framebuffer_get_width (fb) != width ||
cogl_framebuffer_get_height (fb) != height ||
offset_x ||
offset_y)
{
wayland_onscreen->pending_width = width;
wayland_onscreen->pending_height = height;
wayland_onscreen->pending_dx += offset_x;
wayland_onscreen->pending_dy += offset_y;
wayland_onscreen->has_pending = TRUE;
}
}
else
_cogl_framebuffer_winsys_update_size (fb, width, height);
}
static void
notify_resize (CoglContext *context,
Window drawable,
int width,
int height)
{
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglOnscreen *onscreen = find_onscreen_for_xid (context, drawable);
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglOnscreenEGL *egl_onscreen;
if (!onscreen)
return;
egl_onscreen = onscreen->winsys;
_cogl_framebuffer_winsys_update_size (framebuffer, width, height);
/* We only want to notify that a resize happened when the
* application calls cogl_context_dispatch so instead of immediately
* notifying we queue an idle callback */
if (!egl_renderer->resize_notify_idle)
{
egl_renderer->resize_notify_idle =
_cogl_poll_renderer_add_idle (renderer,
flush_pending_resize_notifications_idle,
context,
NULL);
}
egl_onscreen->pending_resize_notify = TRUE;
}
static CoglBool
_cogl_winsys_egl_onscreen_init (CoglOnscreen *onscreen,
EGLConfig egl_config,
CoglError **error)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen;
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
wayland_onscreen = g_slice_new0 (CoglOnscreenWayland);
egl_onscreen->platform = wayland_onscreen;
_cogl_list_init (&wayland_onscreen->frame_callbacks);
if (onscreen->foreign_surface)
wayland_onscreen->wayland_surface = onscreen->foreign_surface;
else
wayland_onscreen->wayland_surface =
wl_compositor_create_surface (wayland_renderer->wayland_compositor);
if (!wayland_onscreen->wayland_surface)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Error while creating wayland surface for CoglOnscreen");
return FALSE;
}
wayland_onscreen->wayland_egl_native_window =
wl_egl_window_create (wayland_onscreen->wayland_surface,
cogl_framebuffer_get_width (framebuffer),
cogl_framebuffer_get_height (framebuffer));
if (!wayland_onscreen->wayland_egl_native_window)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Error while creating wayland egl native window "
"for CoglOnscreen");
return FALSE;
}
egl_onscreen->egl_surface =
eglCreateWindowSurface (egl_renderer->edpy,
egl_config,
(EGLNativeWindowType)
wayland_onscreen->wayland_egl_native_window,
NULL);
if (!onscreen->foreign_surface)
wayland_onscreen->wayland_shell_surface =
wl_shell_get_shell_surface (wayland_renderer->wayland_shell,
wayland_onscreen->wayland_surface);
return TRUE;
}
void
cogl_android_onscreen_update_size (CoglOnscreen *onscreen,
int width,
int height)
{
CoglFramebuffer *fb = COGL_FRAMEBUFFER (onscreen);
_cogl_framebuffer_winsys_update_size (fb, width, height);
}
static CoglBool
_cogl_winsys_onscreen_init (CoglOnscreen *onscreen,
CoglError **error)
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglDisplay *display = context->display;
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayKMS *kms_display = egl_display->platform;
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererKMS *kms_renderer = egl_renderer->platform;
CoglOnscreenEGL *egl_onscreen;
CoglOnscreenKMS *kms_onscreen;
_COGL_RETURN_VAL_IF_FAIL (egl_display->egl_context, FALSE);
onscreen->winsys = g_slice_new0 (CoglOnscreenEGL);
egl_onscreen = onscreen->winsys;
kms_onscreen = g_slice_new0 (CoglOnscreenKMS);
egl_onscreen->platform = kms_onscreen;
kms_onscreen->surface =
gbm_surface_create (kms_renderer->gbm,
kms_display->width,
kms_display->height,
GBM_BO_FORMAT_XRGB8888,
GBM_BO_USE_SCANOUT |
GBM_BO_USE_RENDERING);
if (!kms_onscreen->surface)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Failed to allocate surface");
return FALSE;
}
egl_onscreen->egl_surface =
eglCreateWindowSurface (egl_renderer->edpy,
egl_display->egl_config,
(NativeWindowType) kms_onscreen->surface,
NULL);
if (egl_onscreen->egl_surface == EGL_NO_SURFACE)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Failed to allocate surface");
return FALSE;
}
_cogl_framebuffer_winsys_update_size (framebuffer,
kms_display->width,
kms_display->height);
return TRUE;
}
static CoglBool
_cogl_winsys_onscreen_init (CoglOnscreen *onscreen,
CoglError **error)
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglDisplay *display = context->display;
CoglDisplayEGL *egl_display = display->winsys;
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
EGLint attributes[MAX_EGL_CONFIG_ATTRIBS];
EGLConfig egl_config;
EGLint config_count = 0;
EGLBoolean status;
_COGL_RETURN_VAL_IF_FAIL (egl_display->egl_context, FALSE);
egl_attributes_from_framebuffer_config (display,
&framebuffer->config,
attributes);
status = eglChooseConfig (egl_renderer->edpy,
attributes,
&egl_config, 1,
&config_count);
if (status != EGL_TRUE || config_count == 0)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Failed to find a suitable EGL configuration");
return FALSE;
}
/* Update the real number of samples_per_pixel now that we have
* found an egl_config... */
if (framebuffer->config.samples_per_pixel)
{
EGLint samples;
status = eglGetConfigAttrib (egl_renderer->edpy,
egl_config,
EGL_SAMPLES, &samples);
g_return_val_if_fail (status == EGL_TRUE, TRUE);
framebuffer->samples_per_pixel = samples;
}
onscreen->winsys = g_slice_new0 (CoglOnscreenEGL);
if (egl_renderer->platform_vtable->onscreen_init &&
!egl_renderer->platform_vtable->onscreen_init (onscreen,
egl_config,
error))
{
g_slice_free (CoglOnscreenEGL, onscreen->winsys);
return FALSE;
}
return TRUE;
}
static void
clutter_backend_win32_ensure_context (ClutterBackend *backend,
ClutterStage *stage)
{
ClutterStageWin32 *stage_win32 =
CLUTTER_STAGE_WIN32 (_clutter_stage_get_window (stage));
cogl_set_framebuffer (COGL_FRAMEBUFFER (stage_win32->onscreen));
}
static CoglBool
bind_onscreen (CoglOnscreen *onscreen)
{
CoglFramebuffer *fb = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = fb->context;
CoglDisplayEGL *egl_display = context->display->winsys;
return bind_onscreen_with_context (onscreen, egl_display->egl_context);
}
static void
_cogl_winsys_onscreen_swap_buffers (CoglOnscreen *onscreen)
{
CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
/* The specification for EGL (at least in 1.4) says that the surface
needs to be bound to the current context for the swap to work
although it may change in future. Mesa explicitly checks for this
and just returns an error if this is not the case so we can't
just pretend this isn't in the spec. */
_cogl_framebuffer_flush_state (COGL_FRAMEBUFFER (onscreen),
COGL_FRAMEBUFFER (onscreen),
COGL_FRAMEBUFFER_STATE_BIND);
eglSwapBuffers (egl_renderer->edpy, egl_onscreen->egl_surface);
}
static void
_cogl_winsys_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen,
const int *rectangles,
int n_rectangles)
{
CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
/* The specification for EGL (at least in 1.4) says that the surface
needs to be bound to the current context for the swap to work
although it may change in future. Mesa explicitly checks for this
and just returns an error if this is not the case so we can't
just pretend this isn't in the spec. */
_cogl_framebuffer_flush_state (COGL_FRAMEBUFFER (onscreen),
COGL_FRAMEBUFFER (onscreen),
COGL_FRAMEBUFFER_STATE_BIND);
if (n_rectangles && egl_renderer->pf_eglSwapBuffersWithDamage)
{
CoglFramebuffer *fb = COGL_FRAMEBUFFER (onscreen);
size_t size = n_rectangles * sizeof (int) * 4;
int *flipped = alloca (size);
int i;
memcpy (flipped, rectangles, size);
for (i = 0; i < n_rectangles; i++)
{
const int *rect = rectangles + 4 * i;
int *flip_rect = flipped + 4 * i;
flip_rect[1] = fb->height - rect[1] - rect[3];
}
if (egl_renderer->pf_eglSwapBuffersWithDamage (egl_renderer->edpy,
egl_onscreen->egl_surface,
flipped,
n_rectangles) == EGL_FALSE)
g_warning ("Error reported by eglSwapBuffersWithDamage");
}
else
eglSwapBuffers (egl_renderer->edpy, egl_onscreen->egl_surface);
}
static void
_cogl_winsys_egl_onscreen_deinit (CoglOnscreen *onscreen)
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglDisplay *display = context->display;
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayNull *null_display = egl_display->platform;
null_display->have_onscreen = FALSE;
}
void
_clutter_backend_reset_cogl_framebuffer (ClutterBackend *backend)
{
if (backend->dummy_onscreen == COGL_INVALID_HANDLE)
{
CoglError *internal_error = NULL;
backend->dummy_onscreen = cogl_onscreen_new (backend->cogl_context, 1, 1);
if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (backend->dummy_onscreen),
&internal_error))
{
g_critical ("Unable to create dummy onscreen: %s", internal_error->message);
cogl_error_free (internal_error);
return;
}
}
cogl_set_framebuffer (COGL_FRAMEBUFFER (backend->dummy_onscreen));
}
void
cogl_wayland_onscreen_set_foreign_surface (CoglOnscreen *onscreen,
struct wl_surface *surface)
{
CoglFramebuffer *fb;
fb = COGL_FRAMEBUFFER (onscreen);
_COGL_RETURN_IF_FAIL (!fb->allocated);
onscreen->foreign_surface = surface;
}
static void
clutter_stage_win32_redraw (ClutterStageWindow *stage_window)
{
ClutterStageWin32 *stage_win32 = CLUTTER_STAGE_WIN32 (stage_window);
/* this will cause the stage implementation to be painted */
_clutter_stage_do_paint (stage_win32->wrapper, NULL);
cogl_flush ();
if (stage_win32->onscreen)
cogl_onscreen_swap_buffers (COGL_FRAMEBUFFER (stage_win32->onscreen));
}
static void
cogland_compositor_create_output (CoglandCompositor *compositor,
int x,
int y,
int width_mm,
int height_mm)
{
CoglandOutput *output = g_slice_new0 (CoglandOutput);
CoglFramebuffer *fb;
GError *error = NULL;
CoglandMode *mode;
output->x = x;
output->y = y;
output->width_mm = width_mm;
output->height_mm = height_mm;
output->wayland_output.interface = &wl_output_interface;
wl_display_add_global (compositor->wayland_display,
&wl_output_interface,
output,
bind_output);
output->onscreen = cogl_onscreen_new (compositor->cogl_context,
width_mm, height_mm);
/* Eventually there will be an implicit allocate on first use so this
* will become optional... */
fb = COGL_FRAMEBUFFER (output->onscreen);
if (!cogl_framebuffer_allocate (fb, &error))
g_error ("Failed to allocate framebuffer: %s\n", error->message);
cogl_onscreen_show (output->onscreen);
#if 0
cogl_framebuffer_set_viewport (fb, x, y, width, height);
#else
cogl_push_framebuffer (fb);
cogl_set_viewport (-x, -y,
compositor->virtual_width,
compositor->virtual_height);
cogl_pop_framebuffer ();
#endif
mode = g_slice_new0 (CoglandMode);
mode->flags = 0;
mode->width = width_mm;
mode->height = height_mm;
mode->refresh = 60;
output->modes = g_list_prepend (output->modes, mode);
compositor->outputs = g_list_prepend (compositor->outputs, output);
}
static void
_cogl_winsys_onscreen_update_swap_throttled (CoglOnscreen *onscreen)
{
CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context;
CoglContextSdl2 *sdl_context = context->winsys;
CoglOnscreenSdl2 *sdl_onscreen = onscreen->winsys;
if (sdl_context->current_window != sdl_onscreen->window)
return;
sdl_context->current_window = NULL;
_cogl_winsys_onscreen_bind (onscreen);
}
struct wl_shell_surface *
cogl_wayland_onscreen_get_shell_surface (CoglOnscreen *onscreen)
{
CoglOnscreenEGL *egl_onscreen;
CoglOnscreenWayland *wayland_onscreen;
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), NULL);
egl_onscreen = onscreen->winsys;
wayland_onscreen = egl_onscreen->platform;
return wayland_onscreen->wayland_shell_surface;
}
static void
_cogl_winsys_onscreen_bind (CoglOnscreen *onscreen)
{
CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context;
CoglDisplayEGL *egl_display = context->display->winsys;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
eglMakeCurrent (egl_renderer->edpy,
EGL_NO_SURFACE,
EGL_NO_SURFACE,
egl_display->egl_context);
}