clients/simple-egl.c

   1 /*
   2  * Copyright © 2011 Benjamin Franzke
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <stdbool.h>
  27 #include <math.h>
  28 #include <assert.h>
  29 #include <signal.h>
  30
  31 #include <linux/input.h>
  32
  33 #include <wayland-client.h>
  34 #include <wayland-egl.h>
  35 #include <wayland-cursor.h>
  36
  37 #include <GLES2/gl2.h>
  38 #include <EGL/egl.h>
  39 #include <EGL/eglext.h>
  40
  41 #ifndef EGL_EXT_swap_buffers_with_damage
  42 #define EGL_EXT_swap_buffers_with_damage 1
  43 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
  44 #endif
  45
  46 #ifndef EGL_EXT_buffer_age
  47 #define EGL_EXT_buffer_age 1
  48 #define EGL_BUFFER_AGE_EXT                      0x313D
  49 #endif
  50
  51 struct window;
  52 struct seat;
  53
  54 struct display {
  55         struct wl_display *display;
  56         struct wl_registry *registry;
  57         struct wl_compositor *compositor;
  58         struct wl_shell *shell;
  59         struct wl_seat *seat;
  60         struct wl_pointer *pointer;
  61         struct wl_touch *touch;
  62         struct wl_keyboard *keyboard;
  63         struct wl_shm *shm;
  64         struct wl_cursor_theme *cursor_theme;
  65         struct wl_cursor *default_cursor;
  66         struct wl_surface *cursor_surface;
  67         struct {
  68                 EGLDisplay dpy;
  69                 EGLContext ctx;
  70                 EGLConfig conf;
  71         } egl;
  72         struct window *window;
  73
  74         PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC swap_buffers_with_damage;
  75 };
  76
  77 struct geometry {
  78         int width, height;
  79 };
  80
  81 struct window {
  82         struct display *display;
  83         struct geometry geometry, window_size;
  84         struct {
  85                 GLuint rotation_uniform;
  86                 GLuint pos;
  87                 GLuint col;
  88         } gl;
  89
  90         uint32_t benchmark_time, frames;
  91         struct wl_egl_window *native;
  92         struct wl_surface *surface;
  93         struct wl_shell_surface *shell_surface;
  94         EGLSurface egl_surface;
  95         struct wl_callback *callback;
  96         int fullscreen, configured, opaque, buffer_size, frame_sync;
  97 };
  98
  99 static const char *vert_shader_text =
 100         "uniform mat4 rotation;\n"
 101         "attribute vec4 pos;\n"
 102         "attribute vec4 color;\n"
 103         "varying vec4 v_color;\n"
 104         "void main() {\n"
 105         "  gl_Position = rotation * pos;\n"
 106         "  v_color = color;\n"
 107         "}\n";
 108
 109 static const char *frag_shader_text =
 110         "precision mediump float;\n"
 111         "varying vec4 v_color;\n"
 112         "void main() {\n"
 113         "  gl_FragColor = v_color;\n"
 114         "}\n";
 115
 116 static int running = 1;
 117
 118 static void
 119 init_egl(struct display *display, struct window *window)
 120 {
 121         static const EGLint context_attribs[] = {
 122                 EGL_CONTEXT_CLIENT_VERSION, 2,
 123                 EGL_NONE
 124         };
 125         const char *extensions;
 126
 127         EGLint config_attribs[] = {
 128                 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
 129                 EGL_RED_SIZE, 1,
 130                 EGL_GREEN_SIZE, 1,
 131                 EGL_BLUE_SIZE, 1,
 132                 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
 133                 EGL_NONE
 134         };
 135
 136         EGLint major, minor, n, count, i, size;
 137         EGLConfig *configs;
 138         EGLBoolean ret;
 139
 140         if (window->opaque || window->buffer_size == 16)
 141                 config_attribs[9] = 0;
 142
 143         display->egl.dpy = eglGetDisplay(display->display);
 144         assert(display->egl.dpy);
 145
 146         ret = eglInitialize(display->egl.dpy, &major, &minor);
 147         assert(ret == EGL_TRUE);
 148         ret = eglBindAPI(EGL_OPENGL_ES_API);
 149         assert(ret == EGL_TRUE);
 150
 151         if (!eglGetConfigs(display->egl.dpy, NULL, 0, &count) || count < 1)
 152                 assert(0);
 153
 154         configs = calloc(count, sizeof *configs);
 155         assert(configs);
 156
 157         ret = eglChooseConfig(display->egl.dpy, config_attribs,
 158                               configs, count, &n);
 159         assert(ret && n >= 1);
 160
 161         for (i = 0; i < n; i++) {
 162                 eglGetConfigAttrib(display->egl.dpy,
 163                                    configs[i], EGL_BUFFER_SIZE, &size);
 164                 if (window->buffer_size == size) {
 165                         display->egl.conf = configs[i];
 166                         break;
 167                 }
 168         }
 169         free(configs);
 170         if (display->egl.conf == NULL) {
 171                 fprintf(stderr, "did not find config with buffer size %d\n",
 172                         window->buffer_size);
 173                 exit(EXIT_FAILURE);
 174         }
 175
 176         display->egl.ctx = eglCreateContext(display->egl.dpy,
 177                                             display->egl.conf,
 178                                             EGL_NO_CONTEXT, context_attribs);
 179         assert(display->egl.ctx);
 180
 181         display->swap_buffers_with_damage = NULL;
 182         extensions = eglQueryString(display->egl.dpy, EGL_EXTENSIONS);
 183         if (extensions &&
 184             strstr(extensions, "EGL_EXT_swap_buffers_with_damage") &&
 185             strstr(extensions, "EGL_EXT_buffer_age"))
 186                 display->swap_buffers_with_damage =
 187                         (PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)
 188                         eglGetProcAddress("eglSwapBuffersWithDamageEXT");
 189
 190         if (display->swap_buffers_with_damage)
 191                 printf("has EGL_EXT_buffer_age and EGL_EXT_swap_buffers_with_damage\n");
 192
 193 }
 194
 195 static void
 196 fini_egl(struct display *display)
 197 {
 198         eglTerminate(display->egl.dpy);
 199         eglReleaseThread();
 200 }
 201
 202 static GLuint
 203 create_shader(struct window *window, const char *source, GLenum shader_type)
 204 {
 205         GLuint shader;
 206         GLint status;
 207
 208         shader = glCreateShader(shader_type);
 209         assert(shader != 0);
 210
 211         glShaderSource(shader, 1, (const char **) &source, NULL);
 212         glCompileShader(shader);
 213
 214         glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
 215         if (!status) {
 216                 char log[1000];
 217                 GLsizei len;
 218                 glGetShaderInfoLog(shader, 1000, &len, log);
 219                 fprintf(stderr, "Error: compiling %s: %*s\n",
 220                         shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment",
 221                         len, log);
 222                 exit(1);
 223         }
 224
 225         return shader;
 226 }
 227
 228 static void
 229 init_gl(struct window *window)
 230 {
 231         GLuint frag, vert;
 232         GLuint program;
 233         GLint status;
 234
 235         frag = create_shader(window, frag_shader_text, GL_FRAGMENT_SHADER);
 236         vert = create_shader(window, vert_shader_text, GL_VERTEX_SHADER);
 237
 238         program = glCreateProgram();
 239         glAttachShader(program, frag);
 240         glAttachShader(program, vert);
 241         glLinkProgram(program);
 242
 243         glGetProgramiv(program, GL_LINK_STATUS, &status);
 244         if (!status) {
 245                 char log[1000];
 246                 GLsizei len;
 247                 glGetProgramInfoLog(program, 1000, &len, log);
 248                 fprintf(stderr, "Error: linking:\n%*s\n", len, log);
 249                 exit(1);
 250         }
 251
 252         glUseProgram(program);
 253
 254         window->gl.pos = 0;
 255         window->gl.col = 1;
 256
 257         glBindAttribLocation(program, window->gl.pos, "pos");
 258         glBindAttribLocation(program, window->gl.col, "color");
 259         glLinkProgram(program);
 260
 261         window->gl.rotation_uniform =
 262                 glGetUniformLocation(program, "rotation");
 263 }
 264
 265 static void
 266 handle_ping(void *data, struct wl_shell_surface *shell_surface,
 267             uint32_t serial)
 268 {
 269         wl_shell_surface_pong(shell_surface, serial);
 270 }
 271
 272 static void
 273 handle_configure(void *data, struct wl_shell_surface *shell_surface,
 274                  uint32_t edges, int32_t width, int32_t height)
 275 {
 276         struct window *window = data;
 277
 278         if (window->native)
 279                 wl_egl_window_resize(window->native, width, height, 0, 0);
 280
 281         window->geometry.width = width;
 282         window->geometry.height = height;
 283
 284         if (!window->fullscreen)
 285                 window->window_size = window->geometry;
 286 }
 287
 288 static void
 289 handle_popup_done(void *data, struct wl_shell_surface *shell_surface)
 290 {
 291 }
 292
 293 static const struct wl_shell_surface_listener shell_surface_listener = {
 294         handle_ping,
 295         handle_configure,
 296         handle_popup_done
 297 };
 298
 299 static void
 300 configure_callback(void *data, struct wl_callback *callback, uint32_t  time)
 301 {
 302         struct window *window = data;
 303
 304         wl_callback_destroy(callback);
 305
 306         window->configured = 1;
 307 }
 308
 309 static struct wl_callback_listener configure_callback_listener = {
 310         configure_callback,
 311 };
 312
 313 static void
 314 set_fullscreen(struct window *window, int fullscreen)
 315 {
 316         struct wl_callback *callback;
 317
 318         window->fullscreen = fullscreen;
 319         window->configured = 0;
 320
 321         if (fullscreen) {
 322                 wl_shell_surface_set_fullscreen(window->shell_surface,
 323                                                 WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
 324                                                 0, NULL);
 325                 callback = wl_display_sync(window->display->display);
 326                 wl_callback_add_listener(callback,
 327                                          &configure_callback_listener,
 328                                          window);
 329
 330         } else {
 331                 wl_shell_surface_set_toplevel(window->shell_surface);
 332                 handle_configure(window, window->shell_surface, 0,
 333                                  window->window_size.width,
 334                                  window->window_size.height);
 335                 window->configured = 1;
 336         }
 337 }
 338
 339 static void
 340 create_surface(struct window *window)
 341 {
 342         struct display *display = window->display;
 343         EGLBoolean ret;
 344
 345         window->surface = wl_compositor_create_surface(display->compositor);
 346         window->shell_surface = wl_shell_get_shell_surface(display->shell,
 347                                                            window->surface);
 348
 349         wl_shell_surface_add_listener(window->shell_surface,
 350                                       &shell_surface_listener, window);
 351
 352         window->native =
 353                 wl_egl_window_create(window->surface,
 354                                      window->window_size.width,
 355                                      window->window_size.height);
 356         window->egl_surface =
 357                 eglCreateWindowSurface(display->egl.dpy,
 358                                        display->egl.conf,
 359                                        window->native, NULL);
 360
 361         wl_shell_surface_set_title(window->shell_surface, "simple-egl");
 362
 363         ret = eglMakeCurrent(window->display->egl.dpy, window->egl_surface,
 364                              window->egl_surface, window->display->egl.ctx);
 365         assert(ret == EGL_TRUE);
 366
 367         if (!window->frame_sync)
 368                 eglSwapInterval(display->egl.dpy, 0);
 369
 370         set_fullscreen(window, window->fullscreen);
 371 }
 372
 373 static void
 374 destroy_surface(struct window *window)
 375 {
 376         /* Required, otherwise segfault in egl_dri2.c: dri2_make_current()
 377          * on eglReleaseThread(). */
 378         eglMakeCurrent(window->display->egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE,
 379                        EGL_NO_CONTEXT);
 380
 381         eglDestroySurface(window->display->egl.dpy, window->egl_surface);
 382         wl_egl_window_destroy(window->native);
 383
 384         wl_shell_surface_destroy(window->shell_surface);
 385         wl_surface_destroy(window->surface);
 386
 387         if (window->callback)
 388                 wl_callback_destroy(window->callback);
 389 }
 390
 391 static const struct wl_callback_listener frame_listener;
 392
 393 static void
 394 redraw(void *data, struct wl_callback *callback, uint32_t time)
 395 {
 396         struct window *window = data;
 397         struct display *display = window->display;
 398         static const GLfloat verts[3][2] = {
 399                 { -0.5, -0.5 },
 400                 {  0.5, -0.5 },
 401                 {  0,    0.5 }
 402         };
 403         static const GLfloat colors[3][3] = {
 404                 { 1, 0, 0 },
 405                 { 0, 1, 0 },
 406                 { 0, 0, 1 }
 407         };
 408         GLfloat angle;
 409         GLfloat rotation[4][4] = {
 410                 { 1, 0, 0, 0 },
 411                 { 0, 1, 0, 0 },
 412                 { 0, 0, 1, 0 },
 413                 { 0, 0, 0, 1 }
 414         };
 415         static const uint32_t speed_div = 5, benchmark_interval = 5;
 416         struct wl_region *region;
 417         EGLint rect[4];
 418         EGLint buffer_age = 0;
 419         struct timeval tv;
 420
 421         assert(window->callback == callback);
 422         window->callback = NULL;
 423
 424         if (callback)
 425                 wl_callback_destroy(callback);
 426
 427         if (!window->configured)
 428                 return;
 429
 430         gettimeofday(&tv, NULL);
 431         time = tv.tv_sec * 1000 + tv.tv_usec / 1000;
 432         if (window->frames == 0)
 433                 window->benchmark_time = time;
 434         if (time - window->benchmark_time > (benchmark_interval * 1000)) {
 435                 printf("%d frames in %d seconds: %f fps\n",
 436                        window->frames,
 437                        benchmark_interval,
 438                        (float) window->frames / benchmark_interval);
 439                 window->benchmark_time = time;
 440                 window->frames = 0;
 441         }
 442
 443         angle = (time / speed_div) % 360 * M_PI / 180.0;
 444         rotation[0][0] =  cos(angle);
 445         rotation[0][2] =  sin(angle);
 446         rotation[2][0] = -sin(angle);
 447         rotation[2][2] =  cos(angle);
 448
 449         if (display->swap_buffers_with_damage)
 450                 eglQuerySurface(display->egl.dpy, window->egl_surface,
 451                                 EGL_BUFFER_AGE_EXT, &buffer_age);
 452
 453         glViewport(0, 0, window->geometry.width, window->geometry.height);
 454
 455         glUniformMatrix4fv(window->gl.rotation_uniform, 1, GL_FALSE,
 456                            (GLfloat *) rotation);
 457
 458         glClearColor(0.0, 0.0, 0.0, 0.5);
 459         glClear(GL_COLOR_BUFFER_BIT);
 460
 461         glVertexAttribPointer(window->gl.pos, 2, GL_FLOAT, GL_FALSE, 0, verts);
 462         glVertexAttribPointer(window->gl.col, 3, GL_FLOAT, GL_FALSE, 0, colors);
 463         glEnableVertexAttribArray(window->gl.pos);
 464         glEnableVertexAttribArray(window->gl.col);
 465
 466         glDrawArrays(GL_TRIANGLES, 0, 3);
 467
 468         glDisableVertexAttribArray(window->gl.pos);
 469         glDisableVertexAttribArray(window->gl.col);
 470
 471         if (window->opaque || window->fullscreen) {
 472                 region = wl_compositor_create_region(window->display->compositor);
 473                 wl_region_add(region, 0, 0,
 474                               window->geometry.width,
 475                               window->geometry.height);
 476                 wl_surface_set_opaque_region(window->surface, region);
 477                 wl_region_destroy(region);
 478         } else {
 479                 wl_surface_set_opaque_region(window->surface, NULL);
 480         }
 481
 482         if (display->swap_buffers_with_damage && buffer_age > 0) {
 483                 rect[0] = window->geometry.width / 4 - 1;
 484                 rect[1] = window->geometry.height / 4 - 1;
 485                 rect[2] = window->geometry.width / 2 + 2;
 486                 rect[3] = window->geometry.height / 2 + 2;
 487                 display->swap_buffers_with_damage(display->egl.dpy,
 488                                                   window->egl_surface,
 489                                                   rect, 1);
 490         } else {
 491                 eglSwapBuffers(display->egl.dpy, window->egl_surface);
 492         }
 493         window->frames++;
 494 }
 495
 496 static const struct wl_callback_listener frame_listener = {
 497         redraw
 498 };
 499
 500 static void
 501 pointer_handle_enter(void *data, struct wl_pointer *pointer,
 502                      uint32_t serial, struct wl_surface *surface,
 503                      wl_fixed_t sx, wl_fixed_t sy)
 504 {
 505         struct display *display = data;
 506         struct wl_buffer *buffer;
 507         struct wl_cursor *cursor = display->default_cursor;
 508         struct wl_cursor_image *image;
 509
 510         if (display->window->fullscreen)
 511                 wl_pointer_set_cursor(pointer, serial, NULL, 0, 0);
 512         else if (cursor) {
 513                 image = display->default_cursor->images[0];
 514                 buffer = wl_cursor_image_get_buffer(image);
 515                 wl_pointer_set_cursor(pointer, serial,
 516                                       display->cursor_surface,
 517                                       image->hotspot_x,
 518                                       image->hotspot_y);
 519                 wl_surface_attach(display->cursor_surface, buffer, 0, 0);
 520                 wl_surface_damage(display->cursor_surface, 0, 0,
 521                                   image->width, image->height);
 522                 wl_surface_commit(display->cursor_surface);
 523         }
 524 }
 525
 526 static void
 527 pointer_handle_leave(void *data, struct wl_pointer *pointer,
 528                      uint32_t serial, struct wl_surface *surface)
 529 {
 530 }
 531
 532 static void
 533 pointer_handle_motion(void *data, struct wl_pointer *pointer,
 534                       uint32_t time, wl_fixed_t sx, wl_fixed_t sy)
 535 {
 536 }
 537
 538 static void
 539 pointer_handle_button(void *data, struct wl_pointer *wl_pointer,
 540                       uint32_t serial, uint32_t time, uint32_t button,
 541                       uint32_t state)
 542 {
 543         struct display *display = data;
 544
 545         if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED)
 546                 wl_shell_surface_move(display->window->shell_surface,
 547                                       display->seat, serial);
 548 }
 549
 550 static void
 551 pointer_handle_axis(void *data, struct wl_pointer *wl_pointer,
 552                     uint32_t time, uint32_t axis, wl_fixed_t value)
 553 {
 554 }
 555
 556 static const struct wl_pointer_listener pointer_listener = {
 557         pointer_handle_enter,
 558         pointer_handle_leave,
 559         pointer_handle_motion,
 560         pointer_handle_button,
 561         pointer_handle_axis,
 562 };
 563
 564 static void
 565 touch_handle_down(void *data, struct wl_touch *wl_touch,
 566                   uint32_t serial, uint32_t time, struct wl_surface *surface,
 567                   int32_t id, wl_fixed_t x_w, wl_fixed_t y_w)
 568 {
 569         struct display *d = (struct display *)data;
 570
 571         wl_shell_surface_move(d->window->shell_surface, d->seat, serial);
 572 }
 573
 574 static void
 575 touch_handle_up(void *data, struct wl_touch *wl_touch,
 576                 uint32_t serial, uint32_t time, int32_t id)
 577 {
 578 }
 579
 580 static void
 581 touch_handle_motion(void *data, struct wl_touch *wl_touch,
 582                     uint32_t time, int32_t id, wl_fixed_t x_w, wl_fixed_t y_w)
 583 {
 584 }
 585
 586 static void
 587 touch_handle_frame(void *data, struct wl_touch *wl_touch)
 588 {
 589 }
 590
 591 static void
 592 touch_handle_cancel(void *data, struct wl_touch *wl_touch)
 593 {
 594 }
 595
 596 static const struct wl_touch_listener touch_listener = {
 597         touch_handle_down,
 598         touch_handle_up,
 599         touch_handle_motion,
 600         touch_handle_frame,
 601         touch_handle_cancel,
 602 };
 603
 604 static void
 605 keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
 606                        uint32_t format, int fd, uint32_t size)
 607 {
 608 }
 609
 610 static void
 611 keyboard_handle_enter(void *data, struct wl_keyboard *keyboard,
 612                       uint32_t serial, struct wl_surface *surface,
 613                       struct wl_array *keys)
 614 {
 615 }
 616
 617 static void
 618 keyboard_handle_leave(void *data, struct wl_keyboard *keyboard,
 619                       uint32_t serial, struct wl_surface *surface)
 620 {
 621 }
 622
 623 static void
 624 keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
 625                     uint32_t serial, uint32_t time, uint32_t key,
 626                     uint32_t state)
 627 {
 628         struct display *d = data;
 629
 630         if (key == KEY_F11 && state)
 631                 set_fullscreen(d->window, d->window->fullscreen ^ 1);
 632         else if (key == KEY_ESC && state)
 633                 running = 0;
 634 }
 635
 636 static void
 637 keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard,
 638                           uint32_t serial, uint32_t mods_depressed,
 639                           uint32_t mods_latched, uint32_t mods_locked,
 640                           uint32_t group)
 641 {
 642 }
 643
 644 static const struct wl_keyboard_listener keyboard_listener = {
 645         keyboard_handle_keymap,
 646         keyboard_handle_enter,
 647         keyboard_handle_leave,
 648         keyboard_handle_key,
 649         keyboard_handle_modifiers,
 650 };
 651
 652 static void
 653 seat_handle_capabilities(void *data, struct wl_seat *seat,
 654                          enum wl_seat_capability caps)
 655 {
 656         struct display *d = data;
 657
 658         if ((caps & WL_SEAT_CAPABILITY_POINTER) && !d->pointer) {
 659                 d->pointer = wl_seat_get_pointer(seat);
 660                 wl_pointer_add_listener(d->pointer, &pointer_listener, d);
 661         } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && d->pointer) {
 662                 wl_pointer_destroy(d->pointer);
 663                 d->pointer = NULL;
 664         }
 665
 666         if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !d->keyboard) {
 667                 d->keyboard = wl_seat_get_keyboard(seat);
 668                 wl_keyboard_add_listener(d->keyboard, &keyboard_listener, d);
 669         } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && d->keyboard) {
 670                 wl_keyboard_destroy(d->keyboard);
 671                 d->keyboard = NULL;
 672         }
 673
 674         if ((caps & WL_SEAT_CAPABILITY_TOUCH) && !d->touch) {
 675                 d->touch = wl_seat_get_touch(seat);
 676                 wl_touch_set_user_data(d->touch, d);
 677                 wl_touch_add_listener(d->touch, &touch_listener, d);
 678         } else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && d->touch) {
 679                 wl_touch_destroy(d->touch);
 680                 d->touch = NULL;
 681         }
 682 }
 683
 684 static const struct wl_seat_listener seat_listener = {
 685         seat_handle_capabilities,
 686 };
 687
 688 static void
 689 registry_handle_global(void *data, struct wl_registry *registry,
 690                        uint32_t name, const char *interface, uint32_t version)
 691 {
 692         struct display *d = data;
 693
 694         if (strcmp(interface, "wl_compositor") == 0) {
 695                 d->compositor =
 696                         wl_registry_bind(registry, name,
 697                                          &wl_compositor_interface, 1);
 698         } else if (strcmp(interface, "wl_shell") == 0) {
 699                 d->shell = wl_registry_bind(registry, name,
 700                                             &wl_shell_interface, 1);
 701         } else if (strcmp(interface, "wl_seat") == 0) {
 702                 d->seat = wl_registry_bind(registry, name,
 703                                            &wl_seat_interface, 1);
 704                 wl_seat_add_listener(d->seat, &seat_listener, d);
 705         } else if (strcmp(interface, "wl_shm") == 0) {
 706                 d->shm = wl_registry_bind(registry, name,
 707                                           &wl_shm_interface, 1);
 708                 d->cursor_theme = wl_cursor_theme_load(NULL, 32, d->shm);
 709                 d->default_cursor =
 710                         wl_cursor_theme_get_cursor(d->cursor_theme, "left_ptr");
 711         }
 712 }
 713
 714 static void
 715 registry_handle_global_remove(void *data, struct wl_registry *registry,
 716                               uint32_t name)
 717 {
 718 }
 719
 720 static const struct wl_registry_listener registry_listener = {
 721         registry_handle_global,
 722         registry_handle_global_remove
 723 };
 724
 725 static void
 726 signal_int(int signum)
 727 {
 728         running = 0;
 729 }
 730
 731 static void
 732 usage(int error_code)
 733 {
 734         fprintf(stderr, "Usage: simple-egl [OPTIONS]\n\n"
 735                 "  -f\tRun in fullscreen mode\n"
 736                 "  -o\tCreate an opaque surface\n"
 737                 "  -s\tUse a 16 bpp EGL config\n"
 738                 "  -b\tDon't sync to compositor redraw (eglSwapInterval 0)\n"
 739                 "  -h\tThis help text\n\n");
 740
 741         exit(error_code);
 742 }
 743
 744 int
 745 main(int argc, char **argv)
 746 {
 747         struct sigaction sigint;
 748         struct display display = { 0 };
 749         struct window  window  = { 0 };
 750         int i, ret = 0;
 751
 752         window.display = &display;
 753         display.window = &window;
 754         window.window_size.width  = 250;
 755         window.window_size.height = 250;
 756         window.buffer_size = 32;
 757         window.frame_sync = 1;
 758
 759         for (i = 1; i < argc; i++) {
 760                 if (strcmp("-f", argv[i]) == 0)
 761                         window.fullscreen = 1;
 762                 else if (strcmp("-o", argv[i]) == 0)
 763                         window.opaque = 1;
 764                 else if (strcmp("-s", argv[i]) == 0)
 765                         window.buffer_size = 16;
 766                 else if (strcmp("-b", argv[i]) == 0)
 767                         window.frame_sync = 0;
 768                 else if (strcmp("-h", argv[i]) == 0)
 769                         usage(EXIT_SUCCESS);
 770                 else
 771                         usage(EXIT_FAILURE);
 772         }
 773
 774         display.display = wl_display_connect(NULL);
 775         assert(display.display);
 776
 777         display.registry = wl_display_get_registry(display.display);
 778         wl_registry_add_listener(display.registry,
 779                                  &registry_listener, &display);
 780
 781         wl_display_dispatch(display.display);
 782
 783         init_egl(&display, &window);
 784         create_surface(&window);
 785         init_gl(&window);
 786
 787         display.cursor_surface =
 788                 wl_compositor_create_surface(display.compositor);
 789
 790         sigint.sa_handler = signal_int;
 791         sigemptyset(&sigint.sa_mask);
 792         sigint.sa_flags = SA_RESETHAND;
 793         sigaction(SIGINT, &sigint, NULL);
 794
 795         /* The mainloop here is a little subtle.  Redrawing will cause
 796          * EGL to read events so we can just call
 797          * wl_display_dispatch_pending() to handle any events that got
 798          * queued up as a side effect. */
 799         while (running && ret != -1) {
 800                 wl_display_dispatch_pending(display.display);
 801                 while (!window.configured)
 802                         wl_display_dispatch(display.display);
 803                 redraw(&window, NULL, 0);
 804         }
 805
 806         fprintf(stderr, "simple-egl exiting\n");
 807
 808         destroy_surface(&window);
 809         fini_egl(&display);
 810
 811         wl_surface_destroy(display.cursor_surface);
 812         if (display.cursor_theme)
 813                 wl_cursor_theme_destroy(display.cursor_theme);
 814
 815         if (display.shell)
 816                 wl_shell_destroy(display.shell);
 817
 818         if (display.compositor)
 819                 wl_compositor_destroy(display.compositor);
 820
 821         wl_registry_destroy(display.registry);
 822         wl_display_flush(display.display);
 823         wl_display_disconnect(display.display);
 824
 825         return 0;
 826 }