compositor.c

   1 /*
   2  * Copyright © 2008 Kristian Høgsberg
   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 #include <stdio.h>
  20 #include <string.h>
  21 #include <stdlib.h>
  22 #include <stdint.h>
  23 #include <stdarg.h>
  24 #include <sys/ioctl.h>
  25 #include <fcntl.h>
  26 #include <unistd.h>
  27 #include <cairo.h>
  28 #include <gdk-pixbuf/gdk-pixbuf.h>
  29 #include <math.h>
  30 #include <time.h>
  31 #include <linux/input.h>
  32
  33 #define GL_GLEXT_PROTOTYPES
  34 #define EGL_EGLEXT_PROTOTYPES
  35 #include <GLES2/gl2.h>
  36 #include <GLES2/gl2ext.h>
  37 #include <EGL/egl.h>
  38 #include <EGL/eglext.h>
  39
  40 #include "wayland.h"
  41 #include "wayland-protocol.h"
  42 #include "cairo-util.h"
  43 #include "compositor.h"
  44
  45 const char *option_background = "background.jpg";
  46 int option_connector = 0;
  47
  48 static const GOptionEntry option_entries[] = {
  49         { "background", 'b', 0, G_OPTION_ARG_STRING,
  50           &option_background, "Background image" },
  51         { "connector", 'c', 0, G_OPTION_ARG_INT,
  52           &option_connector, "KMS connector" },
  53         { NULL }
  54 };
  55
  56
  57 static void
  58 wlsc_matrix_init(struct wlsc_matrix *matrix)
  59 {
  60         static const struct wlsc_matrix identity = {
  61                 { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  0, 0, 0, 1 }
  62         };
  63
  64         memcpy(matrix, &identity, sizeof identity);
  65 }
  66
  67 static void
  68 wlsc_matrix_multiply(struct wlsc_matrix *m, const struct wlsc_matrix *n)
  69 {
  70         struct wlsc_matrix tmp;
  71         const GLfloat *row, *column;
  72         div_t d;
  73         int i, j;
  74
  75         for (i = 0; i < 16; i++) {
  76                 tmp.d[i] = 0;
  77                 d = div(i, 4);
  78                 row = m->d + d.quot * 4;
  79                 column = n->d + d.rem;
  80                 for (j = 0; j < 4; j++)
  81                         tmp.d[i] += row[j] * column[j * 4];
  82         }
  83         memcpy(m, &tmp, sizeof tmp);
  84 }
  85
  86 static void
  87 wlsc_matrix_translate(struct wlsc_matrix *matrix, GLfloat x, GLfloat y, GLfloat z)
  88 {
  89         struct wlsc_matrix translate = {
  90                 { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  x, y, z, 1 }
  91         };
  92
  93         wlsc_matrix_multiply(matrix, &translate);
  94 }
  95
  96 static void
  97 wlsc_matrix_scale(struct wlsc_matrix *matrix, GLfloat x, GLfloat y, GLfloat z)
  98 {
  99         struct wlsc_matrix scale = {
 100                 { x, 0, 0, 0,  0, y, 0, 0,  0, 0, z, 0,  0, 0, 0, 1 }
 101         };
 102
 103         wlsc_matrix_multiply(matrix, &scale);
 104 }
 105
 106 static void
 107 wlsc_matrix_rotate(struct wlsc_matrix *matrix,
 108                    GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 109 {
 110         GLfloat c = cos(angle);
 111         GLfloat s = sin(angle);
 112         struct wlsc_matrix rotate = {
 113                 { x * x * (1 - c) + c,     y * x * (1 - c) + z * s, x * z * (1 - c) - y * s, 0,
 114                   x * y * (1 - c) - z * s, y * y * (1 - c) + c,     y * z * (1 - c) + x * s, 0,
 115                   x * z * (1 - c) + y * s, y * z * (1 - c) - x * s, z * z * (1 - c) + c,     0,
 116                   0, 0, 0, 1 }
 117         };
 118
 119         wlsc_matrix_multiply(matrix, &rotate);
 120 }
 121
 122 static void
 123 wlsc_matrix_transform(struct wlsc_matrix *matrix, struct wlsc_vector *v)
 124 {
 125         int i, j;
 126         struct wlsc_vector t;
 127
 128         for (i = 0; i < 4; i++) {
 129                 t.f[i] = 0;
 130                 for (j = 0; j < 4; j++)
 131                         t.f[i] += v->f[j] * matrix->d[i + j * 4];
 132         }
 133
 134         *v = t;
 135 }
 136
 137 static void
 138 wlsc_surface_init(struct wlsc_surface *surface,
 139                   struct wlsc_compositor *compositor, struct wl_visual *visual,
 140                   int32_t x, int32_t y, int32_t width, int32_t height)
 141 {
 142         glGenTextures(1, &surface->texture);
 143         surface->compositor = compositor;
 144         surface->visual = visual;
 145         wlsc_matrix_init(&surface->matrix);
 146         wlsc_matrix_scale(&surface->matrix, width, height, 1);
 147         wlsc_matrix_translate(&surface->matrix, x, y, 0);
 148
 149         wlsc_matrix_init(&surface->matrix_inv);
 150         wlsc_matrix_translate(&surface->matrix_inv, -x, -y, 0);
 151         wlsc_matrix_scale(&surface->matrix_inv, 1.0 / width, 1.0 / height, 1);
 152 }
 153
 154 static struct wlsc_surface *
 155 wlsc_surface_create_from_cairo_surface(struct wlsc_compositor *ec,
 156                                       cairo_surface_t *surface,
 157                                       int x, int y, int width, int height)
 158 {
 159         struct wlsc_surface *es;
 160         int stride;
 161         void *data;
 162
 163         stride = cairo_image_surface_get_stride(surface);
 164         data = cairo_image_surface_get_data(surface);
 165
 166         es = malloc(sizeof *es);
 167         if (es == NULL)
 168                 return NULL;
 169
 170         wlsc_surface_init(es, ec, &ec->premultiplied_argb_visual,
 171                           x, y, width, height);
 172         glBindTexture(GL_TEXTURE_2D, es->texture);
 173         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 174         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 175         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 176         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 177         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
 178                      GL_RGBA, GL_UNSIGNED_BYTE, data);
 179
 180         return es;
 181 }
 182
 183 static void
 184 wlsc_surface_destroy(struct wlsc_surface *surface,
 185                      struct wlsc_compositor *compositor)
 186 {
 187         struct wlsc_listener *l;
 188
 189         wl_list_remove(&surface->link);
 190         glDeleteTextures(1, &surface->texture);
 191         wl_client_remove_surface(surface->base.client, &surface->base);
 192
 193         wl_list_for_each(l, &compositor->surface_destroy_listener_list, link)
 194                 l->func(l, surface);
 195
 196         free(surface);
 197 }
 198
 199 static void
 200 pointer_path(cairo_t *cr, int x, int y)
 201 {
 202         const int end = 3, tx = 4, ty = 12, dx = 5, dy = 10;
 203         const int width = 16, height = 16;
 204
 205         cairo_move_to(cr, x, y);
 206         cairo_line_to(cr, x + tx, y + ty);
 207         cairo_line_to(cr, x + dx, y + dy);
 208         cairo_line_to(cr, x + width - end, y + height);
 209         cairo_line_to(cr, x + width, y + height - end);
 210         cairo_line_to(cr, x + dy, y + dx);
 211         cairo_line_to(cr, x + ty, y + tx);
 212         cairo_close_path(cr);
 213 }
 214
 215 static struct wlsc_surface *
 216 pointer_create(struct wlsc_compositor *ec, int x, int y, int width, int height)
 217 {
 218         struct wlsc_surface *es;
 219         const int hotspot_x = 16, hotspot_y = 16;
 220         cairo_surface_t *surface;
 221         cairo_t *cr;
 222
 223         surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
 224                                              width, height);
 225
 226         cr = cairo_create(surface);
 227         pointer_path(cr, hotspot_x + 5, hotspot_y + 4);
 228         cairo_set_line_width(cr, 2);
 229         cairo_set_source_rgb(cr, 0, 0, 0);
 230         cairo_stroke_preserve(cr);
 231         cairo_fill(cr);
 232         blur_surface(surface, width);
 233
 234         pointer_path(cr, hotspot_x, hotspot_y);
 235         cairo_stroke_preserve(cr);
 236         cairo_set_source_rgb(cr, 1, 1, 1);
 237         cairo_fill(cr);
 238         cairo_destroy(cr);
 239
 240         es = wlsc_surface_create_from_cairo_surface(ec,
 241                                                    surface,
 242                                                    x - hotspot_x,
 243                                                    y - hotspot_y,
 244                                                    width, height);
 245
 246         cairo_surface_destroy(surface);
 247
 248         return es;
 249 }
 250
 251 static struct wlsc_surface *
 252 background_create(struct wlsc_output *output, const char *filename)
 253 {
 254         struct wlsc_surface *background;
 255         GdkPixbuf *pixbuf;
 256         GError *error = NULL;
 257         void *data;
 258         GLenum format;
 259
 260         background = malloc(sizeof *background);
 261         if (background == NULL)
 262                 return NULL;
 263
 264         g_type_init();
 265
 266         pixbuf = gdk_pixbuf_new_from_file_at_scale(filename,
 267                                                    output->width,
 268                                                    output->height,
 269                                                    FALSE, &error);
 270         if (error != NULL) {
 271                 free(background);
 272                 return NULL;
 273         }
 274
 275         data = gdk_pixbuf_get_pixels(pixbuf);
 276
 277         wlsc_surface_init(background, output->compositor,
 278                           &output->compositor->rgb_visual,
 279                           output->x, output->y, output->width, output->height);
 280
 281         glBindTexture(GL_TEXTURE_2D, background->texture);
 282         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 283         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 284         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 285         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 286
 287         if (gdk_pixbuf_get_has_alpha(pixbuf))
 288                 format = GL_RGBA;
 289         else
 290                 format = GL_RGB;
 291
 292         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
 293                      output->width, output->height, 0,
 294                      format, GL_UNSIGNED_BYTE, data);
 295
 296         return background;
 297 }
 298
 299 static void
 300 wlsc_surface_draw(struct wlsc_surface *es, struct wlsc_output *output)
 301 {
 302         struct wlsc_compositor *ec = es->compositor;
 303         struct wlsc_matrix tmp;
 304
 305         tmp = es->matrix;
 306         wlsc_matrix_multiply(&tmp, &output->matrix);
 307         glUniformMatrix4fv(ec->proj_uniform, 1, GL_FALSE, tmp.d);
 308         glUniform1i(ec->tex_uniform, 0);
 309
 310         if (es->visual == &ec->argb_visual) {
 311                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 312                 glEnable(GL_BLEND);
 313         } else if (es->visual == &ec->premultiplied_argb_visual) {
 314                 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 315                 glEnable(GL_BLEND);
 316         } else {
 317                 glDisable(GL_BLEND);
 318         }
 319
 320         glBindTexture(GL_TEXTURE_2D, es->texture);
 321         glEnable(GL_TEXTURE_2D);
 322         glBindBuffer(GL_ARRAY_BUFFER, ec->vbo);
 323         glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
 324                               5 * sizeof(GLfloat), NULL);
 325         glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,
 326                               5 * sizeof(GLfloat), (GLfloat *) 0 + 3);
 327         glEnableVertexAttribArray(0);
 328         glEnableVertexAttribArray(1);
 329         glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 330 }
 331
 332 static void
 333 wlsc_surface_raise(struct wlsc_surface *surface)
 334 {
 335         struct wlsc_compositor *compositor = surface->compositor;
 336
 337         wl_list_remove(&surface->link);
 338         wl_list_insert(compositor->surface_list.prev, &surface->link);
 339 }
 340
 341 static void
 342 wlsc_surface_lower(struct wlsc_surface *surface)
 343 {
 344         struct wlsc_compositor *compositor = surface->compositor;
 345
 346         wl_list_remove(&surface->link);
 347         wl_list_insert(&compositor->surface_list, &surface->link);
 348 }
 349
 350 void
 351 wlsc_compositor_finish_frame(struct wlsc_compositor *compositor, int msecs)
 352 {
 353         wl_display_post_frame(compositor->wl_display,
 354                               &compositor->base,
 355                               compositor->current_frame, msecs);
 356
 357         wl_event_source_timer_update(compositor->timer_source, 5);
 358         compositor->current_frame++;
 359 }
 360
 361 static void
 362 wlsc_output_repaint(struct wlsc_output *output)
 363 {
 364         struct wlsc_compositor *ec = output->compositor;
 365         struct wlsc_surface *es;
 366         struct wlsc_input_device *eid;
 367
 368         glViewport(0, 0, output->width, output->height);
 369
 370         if (output->background)
 371                 wlsc_surface_draw(output->background, output);
 372         else
 373                 glClear(GL_COLOR_BUFFER_BIT);
 374
 375         wl_list_for_each(es, &ec->surface_list, link)
 376                 wlsc_surface_draw(es, output);
 377
 378         if (ec->focus)
 379                 wl_list_for_each(eid, &ec->input_device_list, link)
 380                         wlsc_surface_draw(eid->sprite, output);
 381 }
 382
 383 static void
 384 repaint(void *data)
 385 {
 386         struct wlsc_compositor *ec = data;
 387         struct wlsc_output *output;
 388
 389         if (!ec->repaint_needed) {
 390                 ec->repaint_on_timeout = 0;
 391                 return;
 392         }
 393
 394         wl_list_for_each(output, &ec->output_list, link)
 395                 wlsc_output_repaint(output);
 396
 397         ec->present(ec);
 398
 399         ec->repaint_needed = 0;
 400 }
 401
 402 void
 403 wlsc_compositor_schedule_repaint(struct wlsc_compositor *compositor)
 404 {
 405         compositor->repaint_needed = 1;
 406         if (compositor->repaint_on_timeout)
 407                 return;
 408
 409         wl_event_source_timer_update(compositor->timer_source, 1);
 410         compositor->repaint_on_timeout = 1;
 411 }
 412
 413 static void
 414 surface_destroy(struct wl_client *client,
 415                 struct wl_surface *surface)
 416 {
 417         struct wlsc_surface *es = (struct wlsc_surface *) surface;
 418         struct wlsc_compositor *ec = es->compositor;
 419
 420         wlsc_surface_destroy(es, ec);
 421
 422         wlsc_compositor_schedule_repaint(ec);
 423 }
 424
 425 static void
 426 surface_attach(struct wl_client *client,
 427                struct wl_surface *surface, uint32_t name,
 428                uint32_t width, uint32_t height, uint32_t stride,
 429                struct wl_object *visual)
 430 {
 431         struct wlsc_surface *es = (struct wlsc_surface *) surface;
 432         struct wlsc_compositor *ec = es->compositor;
 433         EGLint attribs[] = {
 434                 EGL_WIDTH,              0,
 435                 EGL_HEIGHT,             0,
 436                 EGL_IMAGE_STRIDE_MESA,  0,
 437                 EGL_IMAGE_FORMAT_MESA,  EGL_IMAGE_FORMAT_ARGB8888_MESA,
 438                 EGL_NONE
 439         };
 440
 441         es->width = width;
 442         es->height = height;
 443
 444         if (visual == &ec->argb_visual.base)
 445                 es->visual = &ec->argb_visual;
 446         else if (visual == &ec->premultiplied_argb_visual.base)
 447                 es->visual = &ec->premultiplied_argb_visual;
 448         else if (visual == &ec->rgb_visual.base)
 449                 es->visual = &ec->rgb_visual;
 450         else
 451                 /* FIXME: Smack client with an exception event */;
 452
 453         glBindTexture(GL_TEXTURE_2D, es->texture);
 454         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 455         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 456         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 457         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 458
 459         if (es->image)
 460                 eglDestroyImageKHR(ec->display, es->image);
 461
 462         attribs[1] = width;
 463         attribs[3] = height;
 464         attribs[5] = stride / 4;
 465
 466         es->image = eglCreateImageKHR(ec->display, ec->context,
 467                                       EGL_DRM_IMAGE_MESA,
 468                                       (EGLClientBuffer) name, attribs);
 469         glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, es->image);
 470
 471 }
 472
 473 static void
 474 surface_map(struct wl_client *client,
 475             struct wl_surface *surface,
 476             int32_t x, int32_t y, int32_t width, int32_t height)
 477 {
 478         struct wlsc_surface *es = (struct wlsc_surface *) surface;
 479
 480         wlsc_matrix_init(&es->matrix);
 481         wlsc_matrix_scale(&es->matrix, width, height, 1);
 482         wlsc_matrix_translate(&es->matrix, x, y, 0);
 483
 484         wlsc_matrix_init(&es->matrix_inv);
 485         wlsc_matrix_translate(&es->matrix_inv, -x, -y, 0);
 486         wlsc_matrix_scale(&es->matrix_inv, 1.0 / width, 1.0 / height, 1);
 487
 488 }
 489
 490 static void
 491 surface_damage(struct wl_client *client,
 492                struct wl_surface *surface,
 493                int32_t x, int32_t y, int32_t width, int32_t height)
 494 {
 495         /* FIXME: This need to take a damage region, of course. */
 496 }
 497
 498 const static struct wl_surface_interface surface_interface = {
 499         surface_destroy,
 500         surface_attach,
 501         surface_map,
 502         surface_damage
 503 };
 504
 505 static void
 506 compositor_create_surface(struct wl_client *client,
 507                           struct wl_compositor *compositor, uint32_t id)
 508 {
 509         struct wlsc_compositor *ec = (struct wlsc_compositor *) compositor;
 510         struct wlsc_surface *surface;
 511
 512         surface = malloc(sizeof *surface);
 513         if (surface == NULL)
 514                 /* FIXME: Send OOM event. */
 515                 return;
 516
 517         wlsc_surface_init(surface, ec, NULL, 0, 0, 0, 0);
 518
 519         wl_list_insert(ec->surface_list.prev, &surface->link);
 520         wl_client_add_surface(client, &surface->base,
 521                               &surface_interface, id);
 522 }
 523
 524 static void
 525 compositor_commit(struct wl_client *client,
 526                   struct wl_compositor *compositor, uint32_t key)
 527 {
 528         struct wlsc_compositor *ec = (struct wlsc_compositor *) compositor;
 529
 530         wlsc_compositor_schedule_repaint(ec);
 531         wl_client_send_acknowledge(client, compositor, key, ec->current_frame);
 532 }
 533
 534 const static struct wl_compositor_interface compositor_interface = {
 535         compositor_create_surface,
 536         compositor_commit
 537 };
 538
 539 static void
 540 wlsc_surface_transform(struct wlsc_surface *surface,
 541                        int32_t x, int32_t y, int32_t *sx, int32_t *sy)
 542 {
 543         struct wlsc_vector v = { { x, y, 0, 1 } };
 544
 545         wlsc_matrix_transform(&surface->matrix_inv, &v);
 546         *sx = v.f[0] * surface->width;
 547         *sy = v.f[1] * surface->height;
 548 }
 549
 550 static void
 551 wlsc_input_device_set_keyboard_focus(struct wlsc_input_device *device,
 552                                      struct wlsc_surface *surface)
 553 {
 554         if (device->keyboard_focus == surface)
 555                 return;
 556
 557         if (device->keyboard_focus &&
 558             (!surface || device->keyboard_focus->base.client != surface->base.client))
 559                 wl_surface_post_event(&device->keyboard_focus->base,
 560                                       &device->base,
 561                                       WL_INPUT_KEYBOARD_FOCUS, NULL, &device->keys);
 562
 563         if (surface)
 564                 wl_surface_post_event(&surface->base,
 565                                       &device->base,
 566                                       WL_INPUT_KEYBOARD_FOCUS,
 567                                       &surface->base, &device->keys);
 568
 569         device->keyboard_focus = surface;
 570 }
 571
 572 static void
 573 wlsc_input_device_set_pointer_focus(struct wlsc_input_device *device,
 574                                     struct wlsc_surface *surface)
 575 {
 576         if (device->pointer_focus == surface)
 577                 return;
 578
 579         if (device->pointer_focus &&
 580             (!surface || device->pointer_focus->base.client != surface->base.client))
 581                 wl_surface_post_event(&device->pointer_focus->base,
 582                                       &device->base,
 583                                       WL_INPUT_POINTER_FOCUS, NULL);
 584         if (surface)
 585                 wl_surface_post_event(&surface->base,
 586                                       &device->base,
 587                                       WL_INPUT_POINTER_FOCUS, &surface->base);
 588
 589         device->pointer_focus = surface;
 590 }
 591
 592 static struct wlsc_surface *
 593 pick_surface(struct wlsc_input_device *device, int32_t *sx, int32_t *sy)
 594 {
 595         struct wlsc_compositor *ec = device->ec;
 596         struct wlsc_surface *es;
 597
 598         if (device->grab > 0) {
 599                 wlsc_surface_transform(device->grab_surface,
 600                                        device->x, device->y, sx, sy);
 601                 return device->grab_surface;
 602         }
 603
 604         wl_list_for_each(es, &ec->surface_list, link) {
 605                 wlsc_surface_transform(es, device->x, device->y, sx, sy);
 606                 if (0 <= *sx && *sx < es->width &&
 607                     0 <= *sy && *sy < es->height)
 608                         return es;
 609         }
 610
 611         return NULL;
 612 }
 613
 614 void
 615 notify_motion(struct wlsc_input_device *device, int x, int y)
 616 {
 617         struct wlsc_surface *es;
 618         struct wlsc_compositor *ec = device->ec;
 619         struct wlsc_output *output;
 620         const int hotspot_x = 16, hotspot_y = 16;
 621         int32_t sx, sy;
 622
 623         /* FIXME: We need some multi head love here. */
 624         output = container_of(ec->output_list.next, struct wlsc_output, link);
 625         if (x < output->x)
 626                 x = 0;
 627         if (y < output->y)
 628                 y = 0;
 629         if (x >= output->x + output->width)
 630                 x = output->x + output->width - 1;
 631         if (y >= output->y + output->height)
 632                 y = output->y + output->height - 1;
 633
 634         device->x = x;
 635         device->y = y;
 636         es = pick_surface(device, &sx, &sy);
 637
 638         wlsc_input_device_set_pointer_focus(device, es);
 639
 640         if (es)
 641                 wl_surface_post_event(&es->base, &device->base,
 642                                       WL_INPUT_MOTION, x, y, sx, sy);
 643
 644         wlsc_matrix_init(&device->sprite->matrix);
 645         wlsc_matrix_scale(&device->sprite->matrix, 64, 64, 1);
 646         wlsc_matrix_translate(&device->sprite->matrix,
 647                               x - hotspot_x, y - hotspot_y, 0);
 648
 649         wlsc_compositor_schedule_repaint(device->ec);
 650 }
 651
 652 void
 653 notify_button(struct wlsc_input_device *device,
 654               int32_t button, int32_t state)
 655 {
 656         struct wlsc_surface *surface;
 657         struct wlsc_compositor *compositor = device->ec;
 658         int32_t sx, sy;
 659
 660         surface = pick_surface(device, &sx, &sy);
 661         if (surface) {
 662                 if (state) {
 663                         wlsc_surface_raise(surface);
 664                         device->grab++;
 665                         device->grab_surface = surface;
 666                         wlsc_input_device_set_keyboard_focus(device,
 667                                                              surface);
 668                 } else {
 669                         device->grab--;
 670                 }
 671
 672                 /* FIXME: Swallow click on raise? */
 673                 wl_surface_post_event(&surface->base, &device->base,
 674                                       WL_INPUT_BUTTON, button, state,
 675                                       device->x, device->y, sx, sy);
 676
 677                 wlsc_compositor_schedule_repaint(compositor);
 678         }
 679 }
 680
 681 void
 682 notify_key(struct wlsc_input_device *device,
 683            uint32_t key, uint32_t state)
 684 {
 685         struct wlsc_compositor *compositor = device->ec;
 686         uint32_t *k, *end;
 687         uint32_t modifier;
 688
 689         switch (key | compositor->modifier_state) {
 690         case KEY_BACKSPACE | MODIFIER_CTRL | MODIFIER_ALT:
 691                 kill(0, SIGTERM);
 692                 return;
 693         }
 694
 695         switch (key) {
 696         case KEY_LEFTCTRL:
 697         case KEY_RIGHTCTRL:
 698                 modifier = MODIFIER_CTRL;
 699                 break;
 700
 701         case KEY_LEFTALT:
 702         case KEY_RIGHTALT:
 703                 modifier = MODIFIER_ALT;
 704                 break;
 705
 706         default:
 707                 modifier = 0;
 708                 break;
 709         }
 710
 711         if (state)
 712                 compositor->modifier_state |= modifier;
 713         else
 714                 compositor->modifier_state &= ~modifier;
 715
 716         end = device->keys.data + device->keys.size;
 717         for (k = device->keys.data; k < end; k++) {
 718                 if (*k == key)
 719                         *k = *--end;
 720         }
 721         device->keys.size = (void *) end - device->keys.data;
 722         if (state) {
 723                 k = wl_array_add(&device->keys, sizeof *k);
 724                 *k = key;
 725         }
 726
 727         if (device->keyboard_focus != NULL)
 728                 wl_surface_post_event(&device->keyboard_focus->base,
 729                                       &device->base,
 730                                       WL_INPUT_KEY, key, state);
 731 }
 732
 733 static void
 734 handle_surface_destroy(struct wlsc_listener *listener,
 735                        struct wlsc_surface *surface)
 736 {
 737         struct wlsc_input_device *device =
 738                 container_of(listener, struct wlsc_input_device, listener);
 739         struct wlsc_surface *focus;
 740         int32_t sx, sy;
 741
 742         if (device->grab_surface == surface) {
 743                 device->grab_surface = NULL;
 744                 device->grab = 0;
 745         }
 746         if (device->keyboard_focus == surface)
 747                 wlsc_input_device_set_keyboard_focus(device, NULL);
 748         if (device->pointer_focus == surface) {
 749                 focus = pick_surface(device, &sx, &sy);
 750                 wlsc_input_device_set_pointer_focus(device, focus);
 751                 fprintf(stderr, "lost pointer focus surface, reverting to %p\n", focus);
 752         }
 753 }
 754
 755 void
 756 wlsc_input_device_init(struct wlsc_input_device *device,
 757                        struct wlsc_compositor *ec)
 758 {
 759         device->base.interface = &wl_input_device_interface;
 760         device->base.implementation = NULL;
 761         wl_display_add_object(ec->wl_display, &device->base);
 762         wl_display_add_global(ec->wl_display, &device->base, NULL);
 763         device->x = 100;
 764         device->y = 100;
 765         device->ec = ec;
 766         device->sprite = pointer_create(ec, device->x, device->y, 64, 64);
 767
 768         device->listener.func = handle_surface_destroy;
 769         wl_list_insert(ec->surface_destroy_listener_list.prev,
 770                        &device->listener.link);
 771         wl_list_insert(ec->input_device_list.prev, &device->link);
 772 }
 773
 774 static void
 775 wlsc_output_post_geometry(struct wl_client *client, struct wl_object *global)
 776 {
 777         struct wlsc_output *output =
 778                 container_of(global, struct wlsc_output, base);
 779
 780         wl_client_post_event(client, global,
 781                              WL_OUTPUT_GEOMETRY,
 782                              output->width, output->height);
 783 }
 784
 785 static const char vertex_shader[] =
 786         "uniform mat4 proj;\n"
 787         "attribute vec4 position;\n"
 788         "attribute vec2 texcoord;\n"
 789         "varying vec2 v_texcoord;\n"
 790         "void main()\n"
 791         "{\n"
 792         "   gl_Position = proj * position;\n"
 793         "   v_texcoord = texcoord;\n"
 794         "}\n";
 795
 796 static const char fragment_shader[] =
 797         /* "precision mediump float;\n" */
 798         "varying vec2 v_texcoord;\n"
 799         "uniform sampler2D tex;\n"
 800         "void main()\n"
 801         "{\n"
 802         "   gl_FragColor = texture2D(tex, v_texcoord)\n;"
 803         "}\n";
 804
 805 static int
 806 init_shaders(struct wlsc_compositor *ec)
 807 {
 808         GLuint v, f, program;
 809         const char *p;
 810         char msg[512];
 811         GLfloat vertices[4 * 5];
 812         GLint status;
 813
 814         p = vertex_shader;
 815         v = glCreateShader(GL_VERTEX_SHADER);
 816         glShaderSource(v, 1, &p, NULL);
 817         glCompileShader(v);
 818         glGetShaderiv(v, GL_COMPILE_STATUS, &status);
 819         if (!status) {
 820                 glGetShaderInfoLog(v, sizeof msg, NULL, msg);
 821                 fprintf(stderr, "vertex shader info: %s\n", msg);
 822                 return -1;
 823         }
 824
 825         p = fragment_shader;
 826         f = glCreateShader(GL_FRAGMENT_SHADER);
 827         glShaderSource(f, 1, &p, NULL);
 828         glCompileShader(f);
 829         glGetShaderiv(f, GL_COMPILE_STATUS, &status);
 830         if (!status) {
 831                 glGetShaderInfoLog(f, sizeof msg, NULL, msg);
 832                 fprintf(stderr, "fragment shader info: %s\n", msg);
 833                 return -1;
 834         }
 835
 836         program = glCreateProgram();
 837         glAttachShader(program, v);
 838         glAttachShader(program, f);
 839         glBindAttribLocation(program, 0, "position");
 840         glBindAttribLocation(program, 1, "texcoord");
 841
 842         glLinkProgram(program);
 843         glGetProgramiv(program, GL_LINK_STATUS, &status);
 844         if (!status) {
 845                 glGetProgramInfoLog(program, sizeof msg, NULL, msg);
 846                 fprintf(stderr, "link info: %s\n", msg);
 847                 return -1;
 848         }
 849
 850         glUseProgram(program);
 851         ec->proj_uniform = glGetUniformLocation(program, "proj");
 852         ec->tex_uniform = glGetUniformLocation(program, "tex");
 853
 854         vertices[ 0] = 0.0;
 855         vertices[ 1] = 0.0;
 856         vertices[ 2] = 0.0;
 857         vertices[ 3] = 0.0;
 858         vertices[ 4] = 0.0;
 859
 860         vertices[ 5] = 0.0;
 861         vertices[ 6] = 1.0;
 862         vertices[ 7] = 0.0;
 863         vertices[ 8] = 0.0;
 864         vertices[ 9] = 1.0;
 865
 866         vertices[10] = 1.0;
 867         vertices[11] = 0.0;
 868         vertices[12] = 0.0;
 869         vertices[13] = 1.0;
 870         vertices[14] = 0.0;
 871
 872         vertices[15] = 1.0;
 873         vertices[16] = 1.0;
 874         vertices[17] = 0.0;
 875         vertices[18] = 1.0;
 876         vertices[19] = 1.0;
 877
 878         glGenBuffers(1, &ec->vbo);
 879         glBindBuffer(GL_ARRAY_BUFFER, ec->vbo);
 880         glBufferData(GL_ARRAY_BUFFER, sizeof vertices, vertices, GL_STATIC_DRAW);
 881
 882         return 0;
 883 }
 884
 885 static const struct wl_interface visual_interface = {
 886         "visual", 1,
 887 };
 888
 889 static void
 890 add_visuals(struct wlsc_compositor *ec)
 891 {
 892         ec->argb_visual.base.interface = &visual_interface;
 893         ec->argb_visual.base.implementation = NULL;
 894         wl_display_add_object(ec->wl_display, &ec->argb_visual.base);
 895         wl_display_add_global(ec->wl_display, &ec->argb_visual.base, NULL);
 896
 897         ec->premultiplied_argb_visual.base.interface = &visual_interface;
 898         ec->premultiplied_argb_visual.base.implementation = NULL;
 899         wl_display_add_object(ec->wl_display,
 900                               &ec->premultiplied_argb_visual.base);
 901         wl_display_add_global(ec->wl_display,
 902                               &ec->premultiplied_argb_visual.base, NULL);
 903
 904         ec->rgb_visual.base.interface = &visual_interface;
 905         ec->rgb_visual.base.implementation = NULL;
 906         wl_display_add_object(ec->wl_display, &ec->rgb_visual.base);
 907         wl_display_add_global(ec->wl_display, &ec->rgb_visual.base, NULL);
 908 }
 909
 910 void
 911 wlsc_output_init(struct wlsc_output *output, struct wlsc_compositor *c,
 912                  int x, int y, int width, int height)
 913 {
 914         output->compositor = c;
 915         output->x = x;
 916         output->y = y;
 917         output->width = width;
 918         output->height = height;
 919
 920         output->background =
 921                 background_create(output, option_background);
 922
 923         wlsc_matrix_init(&output->matrix);
 924         wlsc_matrix_translate(&output->matrix,
 925                               -output->x - output->width / 2.0,
 926                               -output->y - output->height / 2.0, 0);
 927         wlsc_matrix_scale(&output->matrix,
 928                           2.0 / output->width, 2.0 / output->height, 1);
 929
 930         output->base.interface = &wl_output_interface;
 931         wl_display_add_object(c->wl_display, &output->base);
 932         wl_display_add_global(c->wl_display, &output->base,
 933                               wlsc_output_post_geometry);
 934 }
 935
 936 int
 937 wlsc_compositor_init(struct wlsc_compositor *ec, struct wl_display *display)
 938 {
 939         struct wl_event_loop *loop;
 940
 941         ec->wl_display = display;
 942
 943         wl_display_set_compositor(display, &ec->base, &compositor_interface);
 944
 945         add_visuals(ec);
 946
 947         wl_list_init(&ec->surface_list);
 948         wl_list_init(&ec->input_device_list);
 949         wl_list_init(&ec->output_list);
 950         wl_list_init(&ec->surface_destroy_listener_list);
 951
 952         screenshooter_create(ec);
 953
 954         glGenFramebuffers(1, &ec->fbo);
 955         glBindFramebuffer(GL_FRAMEBUFFER, ec->fbo);
 956         glActiveTexture(GL_TEXTURE0);
 957         if (init_shaders(ec) < 0)
 958                 return -1;
 959
 960         loop = wl_display_get_event_loop(ec->wl_display);
 961         ec->timer_source = wl_event_loop_add_timer(loop, repaint, ec);
 962         wlsc_compositor_schedule_repaint(ec);
 963
 964         return 0;
 965 }
 966
 967 /* The plan here is to generate a random anonymous socket name and
 968  * advertise that through a service on the session dbus.
 969  */
 970 static const char socket_name[] = "\0wayland";
 971
 972 int main(int argc, char *argv[])
 973 {
 974         struct wl_display *display;
 975         struct wlsc_compositor *ec;
 976         GError *error = NULL;
 977         GOptionContext *context;
 978
 979         context = g_option_context_new(NULL);
 980         g_option_context_add_main_entries(context, option_entries, "Wayland");
 981         if (!g_option_context_parse(context, &argc, &argv, &error)) {
 982                 fprintf(stderr, "option parsing failed: %s\n", error->message);
 983                 exit(EXIT_FAILURE);
 984         }
 985
 986         display = wl_display_create();
 987
 988         if (getenv("DISPLAY"))
 989                 ec = x11_compositor_create(display);
 990         else
 991                 ec = drm_compositor_create(display);
 992
 993         if (ec == NULL) {
 994                 fprintf(stderr, "failed to create compositor\n");
 995                 exit(EXIT_FAILURE);
 996         }
 997
 998         if (wl_display_add_socket(display, socket_name, sizeof socket_name)) {
 999                 fprintf(stderr, "failed to add socket: %m\n");
1000                 exit(EXIT_FAILURE);
1001         }
1002
1003         wl_display_run(display);
1004
1005         return 0;
1006 }