blob: 524a25c8473310c52b268319cf98295e6c846e4f [file] [log] [blame]
Benjamin Franzkeec2e6422010-11-27 19:04:12 +01001/*
2 * Copyright © 2010 Benjamin Franzke
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software Foundation,
16 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 */
18
19#ifdef HAVE_CONFIG_H
20#include <config.h>
21#endif
22
23#include <stddef.h>
24#define _GNU_SOURCE
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <fcntl.h>
29#include <unistd.h>
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010030
Benjamin Franzkebe014562011-02-18 17:04:24 +010031#include <wayland-client.h>
32#include <wayland-egl.h>
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010033
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010034#include <GLES2/gl2.h>
35#include <GLES2/gl2ext.h>
36#include <EGL/egl.h>
37#include <EGL/eglext.h>
38
39#include "compositor.h"
40
41struct wayland_compositor {
42 struct wlsc_compositor base;
43
44 struct {
45 struct wl_display *display;
Benjamin Franzkebe014562011-02-18 17:04:24 +010046 struct wl_egl_display *egl_display;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010047 struct wl_compositor *compositor;
48 struct wl_shell *shell;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010049 struct wl_output *output;
50
51 struct {
52 int32_t x, y, width, height;
53 } screen_allocation;
54
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010055 struct wl_event_source *wl_source;
56 uint32_t event_mask;
57 } parent;
58
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010059 struct wl_list input_list;
60};
61
62struct wayland_output {
63 struct wlsc_output base;
64
65 struct {
66 struct wl_surface *surface;
Benjamin Franzkebe014562011-02-18 17:04:24 +010067 struct wl_egl_window *egl_window;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010068 } parent;
Benjamin Franzkebe014562011-02-18 17:04:24 +010069 EGLSurface egl_surface;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010070};
71
72struct wayland_input {
73 struct wayland_compositor *compositor;
74 struct wl_input_device *input_device;
75 struct wl_list link;
76};
77
78static int
79wayland_input_create(struct wayland_compositor *c)
80{
81 struct wlsc_input_device *input;
82
83 input = malloc(sizeof *input);
84 if (input == NULL)
85 return -1;
86
87 memset(input, 0, sizeof *input);
88 wlsc_input_device_init(input, &c->base);
89
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -050090 c->base.input_device = &input->input_device;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +010091
92 return 0;
93}
94
95static int
96wayland_compositor_init_egl(struct wayland_compositor *c)
97{
98 EGLint major, minor;
Benjamin Franzkebe014562011-02-18 17:04:24 +010099 EGLint n;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100100 const char *extensions;
Benjamin Franzkebe014562011-02-18 17:04:24 +0100101 EGLint config_attribs[] = {
102 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
103 EGL_RED_SIZE, 1,
104 EGL_GREEN_SIZE, 1,
105 EGL_BLUE_SIZE, 1,
106 EGL_DEPTH_SIZE, 1,
Kristian Høgsbergd28ab362011-03-02 11:36:30 -0500107 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
Benjamin Franzkebe014562011-02-18 17:04:24 +0100108 EGL_NONE
109 };
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100110 static const EGLint context_attribs[] = {
111 EGL_CONTEXT_CLIENT_VERSION, 2,
112 EGL_NONE
113 };
114
Benjamin Franzkebe014562011-02-18 17:04:24 +0100115 c->base.display = eglGetDisplay(c->parent.egl_display);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100116 if (c->base.display == NULL) {
117 fprintf(stderr, "failed to create display\n");
118 return -1;
119 }
120
121 if (!eglInitialize(c->base.display, &major, &minor)) {
122 fprintf(stderr, "failed to initialize display\n");
123 return -1;
124 }
125
126 extensions = eglQueryString(c->base.display, EGL_EXTENSIONS);
127 if (!strstr(extensions, "EGL_KHR_surfaceless_opengl")) {
128 fprintf(stderr, "EGL_KHR_surfaceless_opengl not available\n");
129 return -1;
130 }
131
132 if (!eglBindAPI(EGL_OPENGL_ES_API)) {
133 fprintf(stderr, "failed to bind EGL_OPENGL_ES_API\n");
134 return -1;
135 }
Benjamin Franzkebe014562011-02-18 17:04:24 +0100136 if (!eglChooseConfig(c->base.display, config_attribs,
137 &c->base.config, 1, &n) || n == 0) {
138 fprintf(stderr, "failed to choose config: %d\n", n);
139 return -1;
140 }
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100141
Benjamin Franzkebe014562011-02-18 17:04:24 +0100142 c->base.context = eglCreateContext(c->base.display, c->base.config,
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100143 EGL_NO_CONTEXT, context_attribs);
144 if (c->base.context == NULL) {
145 fprintf(stderr, "failed to create context\n");
146 return -1;
147 }
148
149 if (!eglMakeCurrent(c->base.display, EGL_NO_SURFACE,
150 EGL_NO_SURFACE, c->base.context)) {
151 fprintf(stderr, "failed to make context current\n");
152 return -1;
153 }
154
155 return 0;
156}
157
158static void
Kristian Høgsberg3ada7ec2010-12-01 09:42:10 -0500159frame_callback(void *data, uint32_t time)
160{
161 struct wayland_compositor *c = (struct wayland_compositor *) data;
162
163 wlsc_compositor_finish_frame(&c->base, time);
164}
165
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100166static int
167wayland_output_prepare_render(struct wlsc_output *output_base)
168{
169 struct wayland_output *output = (struct wayland_output *) output_base;
170 struct wlsc_compositor *ec = output->base.compositor;
171
172 if (!eglMakeCurrent(ec->display, output->egl_surface,
173 output->egl_surface, ec->context)) {
174 fprintf(stderr, "failed to make current\n");
175 return -1;
176 }
177
178 return 0;
179}
180
Kristian Høgsberg3ada7ec2010-12-01 09:42:10 -0500181static void
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100182wayland_compositor_present(struct wlsc_compositor *base)
183{
184 struct wayland_compositor *c = (struct wayland_compositor *) base;
185 struct wayland_output *output;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100186
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100187 wl_list_for_each(output, &base->output_list, base.link) {
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100188 if (wayland_output_prepare_render(&output->base))
Benjamin Franzkebe014562011-02-18 17:04:24 +0100189 continue;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100190
Benjamin Franzkebe014562011-02-18 17:04:24 +0100191 eglSwapBuffers(c->base.display, output->egl_surface);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100192 }
193
Kristian Høgsberg3ada7ec2010-12-01 09:42:10 -0500194 wl_display_frame_callback(c->parent.display, frame_callback, c);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100195}
196
197static int
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100198wayland_compositor_create_output(struct wayland_compositor *c,
199 int width, int height)
200{
201 struct wayland_output *output;
202 struct wl_visual *visual;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100203
204 output = malloc(sizeof *output);
205 if (output == NULL)
206 return -1;
207 memset(output, 0, sizeof *output);
208
Benjamin Franzkebe014562011-02-18 17:04:24 +0100209 wlsc_output_init(&output->base, &c->base, 0, 0, width, height,
210 WL_OUTPUT_FLIPPED);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100211 output->parent.surface =
212 wl_compositor_create_surface(c->parent.compositor);
213 wl_surface_set_user_data(output->parent.surface, output);
214
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100215 visual = wl_display_get_premultiplied_argb_visual(c->parent.display);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100216
Benjamin Franzkebe014562011-02-18 17:04:24 +0100217 output->parent.egl_window =
218 wl_egl_window_create(c->parent.egl_display,
219 output->parent.surface,
220 width, height, visual);
221 if (!output->parent.egl_window) {
222 fprintf(stderr, "failure to create wl_egl_window\n");
223 goto cleanup_output;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100224 }
225
Benjamin Franzkebe014562011-02-18 17:04:24 +0100226 output->egl_surface =
227 eglCreateWindowSurface(c->base.display, c->base.config,
228 output->parent.egl_window, NULL);
229 if (!output->egl_surface) {
230 fprintf(stderr, "failed to create window surface\n");
231 goto cleanup_window;
232 }
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100233
Benjamin Franzkebe014562011-02-18 17:04:24 +0100234 if (!eglMakeCurrent(c->base.display, output->egl_surface,
235 output->egl_surface, c->base.context)) {
236 fprintf(stderr, "failed to make surface current\n");
237 goto cleanup_surface;
238 return -1;
239 }
240
Kristian Høgsberg82da52b2010-12-17 09:53:12 -0500241 wl_surface_map_toplevel(output->parent.surface);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100242
243 glClearColor(0, 0, 0, 0.5);
244
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100245 output->base.prepare_render = wayland_output_prepare_render;
246
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100247 wl_list_insert(c->base.output_list.prev, &output->base.link);
248
249 return 0;
Benjamin Franzkebe014562011-02-18 17:04:24 +0100250
251cleanup_surface:
252 eglDestroySurface(c->base.display, output->egl_surface);
253cleanup_window:
254 wl_egl_window_destroy(output->parent.egl_window);
255cleanup_output:
256 /* FIXME: cleanup wlsc_output */
257 free(output);
258
259 return -1;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100260}
261
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100262/* Events received from the wayland-server this compositor is client of: */
263
264/* parent output interface */
265static void
266display_handle_geometry(void *data,
267 struct wl_output *output,
Kristian Høgsbergf8fc08f2010-12-01 20:10:10 -0500268 int32_t x, int32_t y,
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100269 int32_t width, int32_t height)
270{
271 struct wayland_compositor *c = data;
272
Kristian Høgsbergf8fc08f2010-12-01 20:10:10 -0500273 c->parent.screen_allocation.x = x;
274 c->parent.screen_allocation.y = y;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100275 c->parent.screen_allocation.width = width;
276 c->parent.screen_allocation.height = height;
277}
278
279static const struct wl_output_listener output_listener = {
280 display_handle_geometry,
281};
282
283/* parent shell interface */
284static void
285handle_configure(void *data, struct wl_shell *shell,
286 uint32_t time, uint32_t edges,
Kristian Høgsbergcbe6f042010-12-17 09:54:45 -0500287 struct wl_surface *surface, int32_t width, int32_t height)
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100288{
289#if 0
290 struct output *output = wl_surface_get_user_data(surface);
291
292 /* FIXME: add resize? */
293#endif
294}
295
296static const struct wl_shell_listener shell_listener = {
297 handle_configure,
298};
299
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100300/* parent input interface */
301static void
302input_handle_motion(void *data, struct wl_input_device *input_device,
303 uint32_t time,
304 int32_t x, int32_t y, int32_t sx, int32_t sy)
305{
306 struct wayland_input *input = data;
307 struct wayland_compositor *c = input->compositor;
308
309 notify_motion(c->base.input_device, time, sx, sy);
310}
311
312static void
313input_handle_button(void *data,
314 struct wl_input_device *input_device,
315 uint32_t time, uint32_t button, uint32_t state)
316{
317 struct wayland_input *input = data;
318 struct wayland_compositor *c = input->compositor;
319
320 notify_button(c->base.input_device, time, button, state);
321}
322
323static void
324input_handle_key(void *data, struct wl_input_device *input_device,
325 uint32_t time, uint32_t key, uint32_t state)
326{
327 struct wayland_input *input = data;
328 struct wayland_compositor *c = input->compositor;
329
330 notify_key(c->base.input_device, time, key, state);
331}
332
333static void
334input_handle_pointer_focus(void *data,
335 struct wl_input_device *input_device,
336 uint32_t time, struct wl_surface *surface,
337 int32_t x, int32_t y, int32_t sx, int32_t sy)
338{
339 struct wayland_input *input = data;
Kristian Høgsbergaf82bea2011-01-27 20:18:17 -0500340 struct wayland_output *output;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100341 struct wayland_compositor *c = input->compositor;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100342
343 if (surface) {
Kristian Høgsberg93331ff2011-01-26 20:35:07 -0500344 output = wl_surface_get_user_data(surface);
345 notify_pointer_focus(c->base.input_device,
346 time, &output->base, sx, sy);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100347 } else {
Kristian Høgsberg93331ff2011-01-26 20:35:07 -0500348 notify_pointer_focus(c->base.input_device, time, NULL, 0, 0);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100349 }
350}
351
352static void
353input_handle_keyboard_focus(void *data,
354 struct wl_input_device *input_device,
355 uint32_t time,
356 struct wl_surface *surface,
357 struct wl_array *keys)
358{
Kristian Høgsbergaf82bea2011-01-27 20:18:17 -0500359 struct wayland_input *input = data;
360 struct wayland_compositor *c = input->compositor;
361 struct wayland_output *output;
362
363 if (surface) {
364 output = wl_surface_get_user_data(surface);
365 notify_keyboard_focus(c->base.input_device,
366 time, &output->base, keys);
367 } else {
368 notify_keyboard_focus(c->base.input_device, time, NULL, NULL);
369 }
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100370}
371
372static const struct wl_input_device_listener input_device_listener = {
373 input_handle_motion,
374 input_handle_button,
375 input_handle_key,
376 input_handle_pointer_focus,
377 input_handle_keyboard_focus,
378};
379
380static void
381display_add_input(struct wayland_compositor *c, uint32_t id)
382{
383 struct wayland_input *input;
384
385 input = malloc(sizeof *input);
386 if (input == NULL)
387 return;
388
389 memset(input, 0, sizeof *input);
390
391 input->compositor = c;
392 input->input_device = wl_input_device_create(c->parent.display, id);
393 wl_list_insert(c->input_list.prev, &input->link);
394
395 wl_input_device_add_listener(input->input_device,
396 &input_device_listener, input);
397 wl_input_device_set_user_data(input->input_device, input);
398}
399
400static void
401display_handle_global(struct wl_display *display, uint32_t id,
402 const char *interface, uint32_t version, void *data)
403{
404 struct wayland_compositor *c = data;
405
406 if (strcmp(interface, "compositor") == 0) {
407 c->parent.compositor = wl_compositor_create(display, id);
408 } else if (strcmp(interface, "output") == 0) {
409 c->parent.output = wl_output_create(display, id);
410 wl_output_add_listener(c->parent.output, &output_listener, c);
411 } else if (strcmp(interface, "input_device") == 0) {
412 display_add_input(c, id);
413 } else if (strcmp(interface, "shell") == 0) {
414 c->parent.shell = wl_shell_create(display, id);
415 wl_shell_add_listener(c->parent.shell, &shell_listener, c);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100416 }
417}
418
419static int
420update_event_mask(uint32_t mask, void *data)
421{
422 struct wayland_compositor *c = data;
423
424 c->parent.event_mask = mask;
425 if (c->parent.wl_source)
426 wl_event_source_fd_update(c->parent.wl_source, mask);
427
428 return 0;
429}
430
431static void
432wayland_compositor_handle_event(int fd, uint32_t mask, void *data)
433{
434 struct wayland_compositor *c = data;
435
436 if (mask & WL_EVENT_READABLE)
437 wl_display_iterate(c->parent.display, WL_DISPLAY_READABLE);
438 if (mask & WL_EVENT_WRITEABLE)
439 wl_display_iterate(c->parent.display, WL_DISPLAY_WRITABLE);
440}
441
Kristian Høgsbergcaa64422010-12-01 16:52:15 -0500442static void
443wayland_destroy(struct wlsc_compositor *ec)
444{
445 free(ec);
446}
447
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100448struct wlsc_compositor *
449wayland_compositor_create(struct wl_display *display, int width, int height)
450{
451 struct wayland_compositor *c;
452 struct wl_event_loop *loop;
453 int fd;
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100454
455 c = malloc(sizeof *c);
456 if (c == NULL)
457 return NULL;
458
459 memset(c, 0, sizeof *c);
460
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -0500461 c->parent.display = wl_display_connect(NULL);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100462
463 if (c->parent.display == NULL) {
464 fprintf(stderr, "failed to create display: %m\n");
465 return NULL;
466 }
467
468 wl_list_init(&c->input_list);
Benjamin Franzkebe014562011-02-18 17:04:24 +0100469 c->parent.egl_display = wl_egl_display_create(c->parent.display);
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100470 wl_display_add_global_listener(c->parent.display,
471 display_handle_global, c);
472
473 wl_display_iterate(c->parent.display, WL_DISPLAY_READABLE);
474
475 c->base.wl_display = display;
476 if (wayland_compositor_init_egl(c) < 0)
477 return NULL;
478
Benjamin Franzkeecfb2b92011-01-15 12:34:48 +0100479 c->base.destroy = wayland_destroy;
Benjamin Franzkeecfb2b92011-01-15 12:34:48 +0100480 c->base.present = wayland_compositor_present;
Benjamin Franzkec649a922011-03-02 11:56:04 +0100481 c->base.create_buffer = wlsc_shm_buffer_create;
Benjamin Franzkeecfb2b92011-01-15 12:34:48 +0100482
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100483 /* Can't init base class until we have a current egl context */
484 if (wlsc_compositor_init(&c->base, display) < 0)
485 return NULL;
486
487 if (wayland_compositor_create_output(c, width, height) < 0)
488 return NULL;
489
490 if (wayland_input_create(c) < 0)
491 return NULL;
492
493 loop = wl_display_get_event_loop(c->base.wl_display);
494
495 fd = wl_display_get_fd(c->parent.display, update_event_mask, c);
496 c->parent.wl_source =
497 wl_event_loop_add_fd(loop, fd, c->parent.event_mask,
498 wayland_compositor_handle_event, c);
499 if (c->parent.wl_source == NULL)
500 return NULL;
501
Benjamin Franzkeec2e6422010-11-27 19:04:12 +0100502 return &c->base;
503}