blob: 204c8dbef60cde3242b4795920414a734e74c3dd [file] [log] [blame]
Kristian Høgsbergffd710e2008-12-02 15:15:01 -05001/*
2 * Copyright © 2008 Kristian Høgsberg
3 *
Kristian Høgsberg82f6e8a2008-12-19 13:47:53 -05004 * 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.
Kristian Høgsbergffd710e2008-12-02 15:15:01 -05008 *
Kristian Høgsberg82f6e8a2008-12-19 13:47:53 -05009 * 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.
Kristian Høgsbergffd710e2008-12-02 15:15:01 -050017 */
18
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040019#include <stdio.h>
20#include <string.h>
21#include <stdlib.h>
22#include <stdint.h>
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -050023#include <stdarg.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040024#include <sys/ioctl.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040025#include <fcntl.h>
26#include <unistd.h>
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -050027#include <cairo.h>
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -050028#include <gdk-pixbuf/gdk-pixbuf.h>
Kristian Høgsberg54879822008-11-23 17:07:32 -050029#include <math.h>
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -050030#include <time.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040031#include <linux/input.h>
Kristian Høgsberg890bc052008-12-30 14:31:33 -050032
Kristian Høgsberg4adaf5c2009-09-12 16:42:07 -040033#define GL_GLEXT_PROTOTYPES
Kristian Høgsberg3afd45d2010-03-03 09:54:29 -050034#define EGL_EGLEXT_PROTOTYPES
Kristian Høgsberg27803c62010-06-06 22:23:21 -040035#include <GLES2/gl2.h>
36#include <GLES2/gl2ext.h>
Kristian Høgsberg3afd45d2010-03-03 09:54:29 -050037#include <EGL/egl.h>
38#include <EGL/eglext.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040039
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -050040#include "wayland.h"
Kristian Høgsbergfe831a72008-12-21 21:50:23 -050041#include "wayland-protocol.h"
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -050042#include "cairo-util.h"
Kristian Høgsberg82863022010-06-04 21:52:02 -040043#include "compositor.h"
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -050044
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040045const char *option_background = "background.jpg";
46int option_connector = 0;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -050047
48static const GOptionEntry option_entries[] = {
49 { "background", 'b', 0, G_OPTION_ARG_STRING,
50 &option_background, "Background image" },
Kristian Høgsbergf5878fa2009-09-18 17:02:41 -040051 { "connector", 'c', 0, G_OPTION_ARG_INT,
52 &option_connector, "KMS connector" },
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -050053 { NULL }
54};
55
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -050056
57static void
58wlsc_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
67static void
68wlsc_matrix_multiply(struct wlsc_matrix *m, const struct wlsc_matrix *n)
69{
70 struct wlsc_matrix tmp;
Kristian Høgsberg27803c62010-06-06 22:23:21 -040071 const GLfloat *row, *column;
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -050072 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
86static void
Kristian Høgsberg27803c62010-06-06 22:23:21 -040087wlsc_matrix_translate(struct wlsc_matrix *matrix, GLfloat x, GLfloat y, GLfloat z)
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -050088{
Kristian Høgsberg27803c62010-06-06 22:23:21 -040089 struct wlsc_matrix translate = {
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -050090 { 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
96static void
Kristian Høgsberg27803c62010-06-06 22:23:21 -040097wlsc_matrix_scale(struct wlsc_matrix *matrix, GLfloat x, GLfloat y, GLfloat z)
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -050098{
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
106static void
107wlsc_matrix_rotate(struct wlsc_matrix *matrix,
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400108 GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -0500109{
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400110 GLfloat c = cos(angle);
111 GLfloat s = sin(angle);
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -0500112 struct wlsc_matrix rotate = {
113 { x * x * (1 - c) + c, y * x * (1 - c) + z * s, x * z * (1 - c) - y * s, 0,
Kristian Høgsbergfa548852010-03-08 17:16:01 -0500114 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,
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -0500116 0, 0, 0, 1 }
117 };
118
119 wlsc_matrix_multiply(matrix, &rotate);
120}
121
122static void
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400123wlsc_matrix_transform(struct wlsc_matrix *matrix, struct wlsc_vector *v)
124{
125 int i, j;
Kristian Høgsberg0b8646b2010-06-08 15:29:14 -0400126 struct wlsc_vector t;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400127
128 for (i = 0; i < 4; i++) {
Kristian Høgsberg0b8646b2010-06-08 15:29:14 -0400129 t.f[i] = 0;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400130 for (j = 0; j < 4; j++)
Kristian Høgsberg0b8646b2010-06-08 15:29:14 -0400131 t.f[i] += v->f[j] * matrix->d[i + j * 4];
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400132 }
Kristian Høgsberg0b8646b2010-06-08 15:29:14 -0400133
134 *v = t;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400135}
136
137static void
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500138wlsc_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;
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500144 surface->visual = visual;
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400145 wlsc_matrix_init(&surface->matrix);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400146 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);
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -0500152}
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500153
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500154static struct wlsc_surface *
155wlsc_surface_create_from_cairo_surface(struct wlsc_compositor *ec,
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500156 cairo_surface_t *surface,
Kristian Høgsberg54879822008-11-23 17:07:32 -0500157 int x, int y, int width, int height)
158{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500159 struct wlsc_surface *es;
Kristian Høgsberg54879822008-11-23 17:07:32 -0500160 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
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500170 wlsc_surface_init(es, ec, &ec->premultiplied_argb_visual,
171 x, y, width, height);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500172 glBindTexture(GL_TEXTURE_2D, es->texture);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400173 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);
Kristian Høgsberg98fed0f2008-12-09 13:35:35 -0500175 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
176 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500177 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400178 GL_RGBA, GL_UNSIGNED_BYTE, data);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500179
Kristian Høgsberg54879822008-11-23 17:07:32 -0500180 return es;
181}
182
183static void
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400184wlsc_surface_destroy(struct wlsc_surface *surface,
185 struct wlsc_compositor *compositor)
Kristian Høgsberg54879822008-11-23 17:07:32 -0500186{
Kristian Høgsberga5db5892010-02-26 10:28:44 -0500187 struct wlsc_listener *l;
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400188
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -0400189 wl_list_remove(&surface->link);
190 glDeleteTextures(1, &surface->texture);
191 wl_client_remove_surface(surface->base.client, &surface->base);
192
Kristian Høgsberga5db5892010-02-26 10:28:44 -0500193 wl_list_for_each(l, &compositor->surface_destroy_listener_list, link)
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400194 l->func(l, surface);
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400195
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400196 free(surface);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500197}
198
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400199static void
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500200pointer_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
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500215static struct wlsc_surface *
216pointer_create(struct wlsc_compositor *ec, int x, int y, int width, int height)
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500217{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500218 struct wlsc_surface *es;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500219 const int hotspot_x = 16, hotspot_y = 16;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500220 cairo_surface_t *surface;
221 cairo_t *cr;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500222
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);
Kristian Høgsberg0ab26242008-12-21 19:33:09 -0500228 cairo_set_line_width(cr, 2);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500229 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
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500240 es = wlsc_surface_create_from_cairo_surface(ec,
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500241 surface,
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500242 x - hotspot_x,
243 y - hotspot_y,
244 width, height);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500245
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500246 cairo_surface_destroy(surface);
247
Kristian Høgsberg54879822008-11-23 17:07:32 -0500248 return es;
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500249}
250
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500251static struct wlsc_surface *
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500252background_create(struct wlsc_output *output, const char *filename)
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500253{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500254 struct wlsc_surface *background;
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500255 GdkPixbuf *pixbuf;
256 GError *error = NULL;
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500257 void *data;
Ray Strode18fd33c2008-12-18 21:05:20 -0500258 GLenum format;
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500259
260 background = malloc(sizeof *background);
261 if (background == NULL)
262 return NULL;
263
264 g_type_init();
265
Kristian Høgsberg0ab26242008-12-21 19:33:09 -0500266 pixbuf = gdk_pixbuf_new_from_file_at_scale(filename,
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500267 output->width,
268 output->height,
Kristian Høgsberg0ab26242008-12-21 19:33:09 -0500269 FALSE, &error);
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500270 if (error != NULL) {
271 free(background);
272 return NULL;
273 }
274
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500275 data = gdk_pixbuf_get_pixels(pixbuf);
276
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500277 wlsc_surface_init(background, output->compositor,
278 &output->compositor->rgb_visual,
279 output->x, output->y, output->width, output->height);
280
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500281 glBindTexture(GL_TEXTURE_2D, background->texture);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400282 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);
Kristian Høgsbergfdec2362001-01-01 22:23:51 -0500284 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
285 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
Ray Strode18fd33c2008-12-18 21:05:20 -0500286
Kristian Høgsberg0ab26242008-12-21 19:33:09 -0500287 if (gdk_pixbuf_get_has_alpha(pixbuf))
Ray Strode18fd33c2008-12-18 21:05:20 -0500288 format = GL_RGBA;
Kristian Høgsberg0ab26242008-12-21 19:33:09 -0500289 else
Ray Strode18fd33c2008-12-18 21:05:20 -0500290 format = GL_RGB;
Ray Strode18fd33c2008-12-18 21:05:20 -0500291
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500292 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
293 output->width, output->height, 0,
Ray Strode18fd33c2008-12-18 21:05:20 -0500294 format, GL_UNSIGNED_BYTE, data);
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500295
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500296 return background;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500297}
298
299static void
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400300wlsc_surface_draw(struct wlsc_surface *es, struct wlsc_output *output)
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500301{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500302 struct wlsc_compositor *ec = es->compositor;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400303 struct wlsc_matrix tmp;
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500304
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400305 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);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500309
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500310 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
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500320 glBindTexture(GL_TEXTURE_2D, es->texture);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500321 glEnable(GL_TEXTURE_2D);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400322 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);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500330}
331
332static void
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400333wlsc_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
341static void
342wlsc_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
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400350void
351wlsc_compositor_finish_frame(struct wlsc_compositor *compositor, int msecs)
Kristian Høgsberg01f941b2009-05-27 17:47:15 -0400352{
Kristian Høgsberg01f941b2009-05-27 17:47:15 -0400353 wl_display_post_frame(compositor->wl_display,
354 &compositor->base,
355 compositor->current_frame, msecs);
356
Kristian Høgsberg5d312db2009-09-12 16:57:02 -0400357 wl_event_source_timer_update(compositor->timer_source, 5);
Kristian Høgsberg01f941b2009-05-27 17:47:15 -0400358 compositor->repaint_on_timeout = 1;
359
Kristian Høgsberg01f941b2009-05-27 17:47:15 -0400360 compositor->current_frame++;
361}
362
363static void
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400364wlsc_output_repaint(struct wlsc_output *output)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400365{
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500366 struct wlsc_compositor *ec = output->compositor;
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500367 struct wlsc_surface *es;
Kristian Høgsberg82f6e8a2008-12-19 13:47:53 -0500368 struct wlsc_input_device *eid;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500369
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500370 glViewport(0, 0, output->width, output->height);
Kristian Høgsbergfdec2362001-01-01 22:23:51 -0500371
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500372 if (output->background)
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400373 wlsc_surface_draw(output->background, output);
Kristian Høgsberg5b7f8322008-12-18 12:08:19 -0500374 else
375 glClear(GL_COLOR_BUFFER_BIT);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400376
Kristian Høgsberga5db5892010-02-26 10:28:44 -0500377 wl_list_for_each(es, &ec->surface_list, link)
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400378 wlsc_surface_draw(es, output);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400379
Kristian Høgsberga5db5892010-02-26 10:28:44 -0500380 wl_list_for_each(eid, &ec->input_device_list, link)
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400381 wlsc_surface_draw(eid->sprite, output);
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500382
Kristian Høgsberg01f941b2009-05-27 17:47:15 -0400383 output->current ^= 1;
Kristian Høgsberga341fa02010-01-24 18:10:15 -0500384
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400385 glFramebufferRenderbuffer(GL_FRAMEBUFFER,
386 GL_COLOR_ATTACHMENT0,
387 GL_RENDERBUFFER,
Kristian Høgsberga341fa02010-01-24 18:10:15 -0500388 output->rbo[output->current]);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500389}
390
391static void
392repaint(void *data)
393{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500394 struct wlsc_compositor *ec = data;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500395 struct wlsc_output *output;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500396
397 if (!ec->repaint_needed) {
398 ec->repaint_on_timeout = 0;
399 return;
400 }
401
Kristian Høgsberga5db5892010-02-26 10:28:44 -0500402 wl_list_for_each(output, &ec->output_list, link)
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400403 wlsc_output_repaint(output);
404
405 wlsc_compositor_present_drm(ec);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500406
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500407 ec->repaint_needed = 0;
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400408}
409
Kristian Høgsberg5503bf82008-11-06 10:38:17 -0500410static void
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400411wlsc_compositor_schedule_repaint(struct wlsc_compositor *compositor)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400412{
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400413 compositor->repaint_needed = 1;
Kristian Høgsbergb0a167c2009-08-14 11:15:18 -0400414 if (compositor->repaint_on_timeout)
415 return;
416
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400417 wl_event_source_timer_update(compositor->timer_source, 1);
418 compositor->repaint_on_timeout = 1;
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400419}
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -0500420
Kristian Høgsberg5503bf82008-11-06 10:38:17 -0500421static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500422surface_destroy(struct wl_client *client,
423 struct wl_surface *surface)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400424{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500425 struct wlsc_surface *es = (struct wlsc_surface *) surface;
426 struct wlsc_compositor *ec = es->compositor;
Kristian Høgsberg2d9cd1e2008-11-03 08:09:34 -0500427
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500428 wlsc_surface_destroy(es, ec);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400429
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400430 wlsc_compositor_schedule_repaint(ec);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400431}
432
Kristian Høgsberg5503bf82008-11-06 10:38:17 -0500433static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500434surface_attach(struct wl_client *client,
435 struct wl_surface *surface, uint32_t name,
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500436 uint32_t width, uint32_t height, uint32_t stride,
437 struct wl_object *visual)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400438{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500439 struct wlsc_surface *es = (struct wlsc_surface *) surface;
440 struct wlsc_compositor *ec = es->compositor;
Kristian Høgsberg3afd45d2010-03-03 09:54:29 -0500441 EGLint attribs[] = {
Kristian Høgsberga2ee6752010-06-04 22:14:28 -0400442 EGL_WIDTH, 0,
443 EGL_HEIGHT, 0,
Kristian Høgsberga2ee6752010-06-04 22:14:28 -0400444 EGL_IMAGE_STRIDE_MESA, 0,
Kristian Høgsberg6619d382010-06-07 12:23:01 -0400445 EGL_IMAGE_FORMAT_MESA, EGL_IMAGE_FORMAT_ARGB8888_MESA,
Kristian Høgsberg3afd45d2010-03-03 09:54:29 -0500446 EGL_NONE
447 };
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400448
Kristian Høgsberg715a0812008-12-10 10:42:04 -0500449 es->width = width;
450 es->height = height;
Kristian Høgsberg4adaf5c2009-09-12 16:42:07 -0400451
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500452 if (visual == &ec->argb_visual.base)
453 es->visual = &ec->argb_visual;
454 else if (visual == &ec->premultiplied_argb_visual.base)
455 es->visual = &ec->premultiplied_argb_visual;
Kristian Høgsberge10b8282008-12-18 19:58:44 -0500456 else if (visual == &ec->rgb_visual.base)
457 es->visual = &ec->rgb_visual;
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500458 else
459 /* FIXME: Smack client with an exception event */;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400460
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500461 glBindTexture(GL_TEXTURE_2D, es->texture);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400462 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
463 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
Kristian Høgsberg98fed0f2008-12-09 13:35:35 -0500464 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
465 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
Kristian Høgsberg3afd45d2010-03-03 09:54:29 -0500466
467 if (es->image)
468 eglDestroyImageKHR(ec->display, es->image);
469
470 attribs[1] = width;
471 attribs[3] = height;
Kristian Høgsberg12923832010-06-06 22:44:12 -0400472 attribs[5] = stride / 4;
Kristian Høgsberg3afd45d2010-03-03 09:54:29 -0500473
474 es->image = eglCreateImageKHR(ec->display, ec->context,
Kristian Høgsberg12923832010-06-06 22:44:12 -0400475 EGL_DRM_IMAGE_MESA,
476 (EGLClientBuffer) name, attribs);
Kristian Høgsberg3afd45d2010-03-03 09:54:29 -0500477 glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, es->image);
Kristian Høgsberg4adaf5c2009-09-12 16:42:07 -0400478
Kristian Høgsbergf9212892008-10-11 18:40:23 -0400479}
480
Kristian Høgsberg5503bf82008-11-06 10:38:17 -0500481static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500482surface_map(struct wl_client *client,
483 struct wl_surface *surface,
484 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400485{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500486 struct wlsc_surface *es = (struct wlsc_surface *) surface;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400487
Kristian Høgsberg2cdc1842010-06-08 10:44:38 -0400488 wlsc_matrix_init(&es->matrix);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400489 wlsc_matrix_scale(&es->matrix, width, height, 1);
Kristian Høgsberg2cdc1842010-06-08 10:44:38 -0400490 wlsc_matrix_translate(&es->matrix, x, y, 0);
Kristian Høgsberg0b8646b2010-06-08 15:29:14 -0400491
492 wlsc_matrix_init(&es->matrix_inv);
493 wlsc_matrix_translate(&es->matrix_inv, -x, -y, 0);
494 wlsc_matrix_scale(&es->matrix_inv, 1.0 / width, 1.0 / height, 1);
495
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400496}
497
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -0500498static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500499surface_damage(struct wl_client *client,
500 struct wl_surface *surface,
501 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -0500502{
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500503 /* FIXME: This need to take a damage region, of course. */
504}
505
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500506const static struct wl_surface_interface surface_interface = {
507 surface_destroy,
508 surface_attach,
509 surface_map,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500510 surface_damage
511};
512
513static void
514compositor_create_surface(struct wl_client *client,
515 struct wl_compositor *compositor, uint32_t id)
516{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500517 struct wlsc_compositor *ec = (struct wlsc_compositor *) compositor;
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400518 struct wlsc_surface *surface;
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500519
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400520 surface = malloc(sizeof *surface);
521 if (surface == NULL)
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500522 /* FIXME: Send OOM event. */
523 return;
524
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400525 wlsc_surface_init(surface, ec, NULL, 0, 0, 0, 0);
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -0500526
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400527 wl_list_insert(ec->surface_list.prev, &surface->link);
528 wl_client_add_surface(client, &surface->base,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500529 &surface_interface, id);
530}
531
532static void
533compositor_commit(struct wl_client *client,
534 struct wl_compositor *compositor, uint32_t key)
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500535{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500536 struct wlsc_compositor *ec = (struct wlsc_compositor *) compositor;
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -0500537
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400538 wlsc_compositor_schedule_repaint(ec);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500539 wl_client_send_acknowledge(client, compositor, key, ec->current_frame);
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -0500540}
541
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500542const static struct wl_compositor_interface compositor_interface = {
543 compositor_create_surface,
544 compositor_commit
545};
546
Kristian Høgsberg7b6907f2009-02-14 17:47:55 -0500547static void
548wlsc_surface_transform(struct wlsc_surface *surface,
549 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
550{
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400551 struct wlsc_vector v = { { x, y, 0, 1 } };
552
553 wlsc_matrix_transform(&surface->matrix_inv, &v);
Kristian Høgsberg0b8646b2010-06-08 15:29:14 -0400554 *sx = v.f[0] * surface->width;
555 *sy = v.f[1] * surface->height;
Kristian Høgsberg7b6907f2009-02-14 17:47:55 -0500556}
557
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -0500558static void
559wlsc_input_device_set_keyboard_focus(struct wlsc_input_device *device,
560 struct wlsc_surface *surface)
561{
562 if (device->keyboard_focus == surface)
563 return;
564
565 if (device->keyboard_focus &&
566 (!surface || device->keyboard_focus->base.client != surface->base.client))
567 wl_surface_post_event(&device->keyboard_focus->base,
568 &device->base,
Kristian Høgsberg786ca0d2009-03-06 21:25:21 -0500569 WL_INPUT_KEYBOARD_FOCUS, NULL, &device->keys);
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -0500570
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -0500571 if (surface)
572 wl_surface_post_event(&surface->base,
573 &device->base,
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -0500574 WL_INPUT_KEYBOARD_FOCUS,
575 &surface->base, &device->keys);
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -0500576
577 device->keyboard_focus = surface;
578}
579
580static void
581wlsc_input_device_set_pointer_focus(struct wlsc_input_device *device,
582 struct wlsc_surface *surface)
583{
584 if (device->pointer_focus == surface)
585 return;
586
587 if (device->pointer_focus &&
588 (!surface || device->pointer_focus->base.client != surface->base.client))
589 wl_surface_post_event(&device->pointer_focus->base,
590 &device->base,
591 WL_INPUT_POINTER_FOCUS, NULL);
592 if (surface)
593 wl_surface_post_event(&surface->base,
594 &device->base,
595 WL_INPUT_POINTER_FOCUS, &surface->base);
596
597 device->pointer_focus = surface;
598}
599
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500600static struct wlsc_surface *
Kristian Høgsberg7e972a52008-12-21 17:26:00 -0500601pick_surface(struct wlsc_input_device *device, int32_t *sx, int32_t *sy)
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500602{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500603 struct wlsc_compositor *ec = device->ec;
604 struct wlsc_surface *es;
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500605
Kristian Høgsberg7b6907f2009-02-14 17:47:55 -0500606 if (device->grab > 0) {
607 wlsc_surface_transform(device->grab_surface,
608 device->x, device->y, sx, sy);
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500609 return device->grab_surface;
Kristian Høgsberg7b6907f2009-02-14 17:47:55 -0500610 }
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500611
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400612 wl_list_for_each(es, &ec->surface_list, link) {
613 wlsc_surface_transform(es, device->x, device->y, sx, sy);
614 if (0 <= *sx && *sx < es->width &&
615 0 <= *sy && *sy < es->height)
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500616 return es;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400617 }
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500618
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500619 return NULL;
620}
621
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500622void
Kristian Høgsberg82f6e8a2008-12-19 13:47:53 -0500623notify_motion(struct wlsc_input_device *device, int x, int y)
Kristian Høgsberg715a0812008-12-10 10:42:04 -0500624{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500625 struct wlsc_surface *es;
626 struct wlsc_compositor *ec = device->ec;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500627 struct wlsc_output *output;
Kristian Høgsberg715a0812008-12-10 10:42:04 -0500628 const int hotspot_x = 16, hotspot_y = 16;
629 int32_t sx, sy;
630
Ray Strodee96dcb82008-12-20 02:00:49 -0500631 if (!ec->vt_active)
632 return;
633
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500634 /* FIXME: We need some multi head love here. */
635 output = container_of(ec->output_list.next, struct wlsc_output, link);
636 if (x < output->x)
Ray Strode90e701d2008-12-18 23:05:43 -0500637 x = 0;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500638 if (y < output->y)
Ray Strode90e701d2008-12-18 23:05:43 -0500639 y = 0;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500640 if (x >= output->x + output->width)
641 x = output->x + output->width - 1;
642 if (y >= output->y + output->height)
643 y = output->y + output->height - 1;
Ray Strode90e701d2008-12-18 23:05:43 -0500644
Kristian Høgsberge3ef3e52008-12-21 19:30:01 -0500645 device->x = x;
646 device->y = y;
Kristian Høgsberg7e972a52008-12-21 17:26:00 -0500647 es = pick_surface(device, &sx, &sy);
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -0500648
649 wlsc_input_device_set_pointer_focus(device, es);
650
Kristian Høgsberg7e972a52008-12-21 17:26:00 -0500651 if (es)
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500652 wl_surface_post_event(&es->base, &device->base,
Kristian Høgsberg5a75c902008-12-10 13:16:50 -0500653 WL_INPUT_MOTION, x, y, sx, sy);
Kristian Høgsberg715a0812008-12-10 10:42:04 -0500654
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400655 wlsc_matrix_init(&device->sprite->matrix);
656 wlsc_matrix_scale(&device->sprite->matrix, 64, 64, 1);
657 wlsc_matrix_translate(&device->sprite->matrix,
658 x - hotspot_x, y - hotspot_y, 0);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500659
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400660 wlsc_compositor_schedule_repaint(device->ec);
Kristian Høgsberg715a0812008-12-10 10:42:04 -0500661}
662
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500663void
Kristian Høgsberg82f6e8a2008-12-19 13:47:53 -0500664notify_button(struct wlsc_input_device *device,
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500665 int32_t button, int32_t state)
Kristian Høgsbergeac149a2008-12-10 00:24:18 -0500666{
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400667 struct wlsc_surface *surface;
668 struct wlsc_compositor *compositor = device->ec;
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500669 int32_t sx, sy;
Kristian Høgsbergeac149a2008-12-10 00:24:18 -0500670
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400671 if (!compositor->vt_active)
Ray Strodee96dcb82008-12-20 02:00:49 -0500672 return;
673
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400674 surface = pick_surface(device, &sx, &sy);
675 if (surface) {
Kristian Høgsberg29573bc2008-12-11 23:27:27 -0500676 if (state) {
Kristian Høgsbergffbc6072009-09-18 17:03:18 -0400677 wlsc_surface_raise(surface);
Kristian Høgsberg29573bc2008-12-11 23:27:27 -0500678 device->grab++;
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400679 device->grab_surface = surface;
680 wlsc_input_device_set_keyboard_focus(device,
681 surface);
Kristian Høgsberg29573bc2008-12-11 23:27:27 -0500682 } else {
683 device->grab--;
684 }
685
Kristian Høgsberg5a75c902008-12-10 13:16:50 -0500686 /* FIXME: Swallow click on raise? */
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400687 wl_surface_post_event(&surface->base, &device->base,
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500688 WL_INPUT_BUTTON, button, state,
689 device->x, device->y, sx, sy);
Kristian Høgsbergeac149a2008-12-10 00:24:18 -0500690
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400691 wlsc_compositor_schedule_repaint(compositor);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500692 }
Kristian Høgsbergeac149a2008-12-10 00:24:18 -0500693}
694
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500695void
Kristian Høgsberg82f6e8a2008-12-19 13:47:53 -0500696notify_key(struct wlsc_input_device *device,
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500697 uint32_t key, uint32_t state)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500698{
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400699 struct wlsc_compositor *compositor = device->ec;
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -0500700 uint32_t *k, *end;
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -0400701 uint32_t modifier;
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -0500702
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400703 if (!compositor->vt_active)
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -0500704 return;
Ray Strodee96dcb82008-12-20 02:00:49 -0500705
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -0400706 switch (key | compositor->modifier_state) {
707 case KEY_BACKSPACE | MODIFIER_CTRL | MODIFIER_ALT:
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400708 kill(0, SIGTERM);
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -0500709 return;
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -0500710 }
Kristian Høgsbergab909ae2001-01-01 22:24:24 -0500711
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -0400712 switch (key) {
713 case KEY_LEFTCTRL:
714 case KEY_RIGHTCTRL:
715 modifier = MODIFIER_CTRL;
716 break;
717
718 case KEY_LEFTALT:
719 case KEY_RIGHTALT:
720 modifier = MODIFIER_ALT;
721 break;
722
723 default:
724 modifier = 0;
725 break;
726 }
727
728 if (state)
729 compositor->modifier_state |= modifier;
730 else
731 compositor->modifier_state &= ~modifier;
732
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -0500733 end = device->keys.data + device->keys.size;
734 for (k = device->keys.data; k < end; k++) {
735 if (*k == key)
736 *k = *--end;
737 }
738 device->keys.size = (void *) end - device->keys.data;
739 if (state) {
740 k = wl_array_add(&device->keys, sizeof *k);
741 *k = key;
742 }
Ray Strodee96dcb82008-12-20 02:00:49 -0500743
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -0500744 if (device->keyboard_focus != NULL)
745 wl_surface_post_event(&device->keyboard_focus->base,
Kristian Høgsberg2c0e56b2008-12-19 13:54:40 -0500746 &device->base,
747 WL_INPUT_KEY, key, state);
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500748}
749
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400750static void
751handle_surface_destroy(struct wlsc_listener *listener,
752 struct wlsc_surface *surface)
753{
754 struct wlsc_input_device *device =
755 container_of(listener, struct wlsc_input_device, listener);
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -0400756 struct wlsc_surface *focus;
757 int32_t sx, sy;
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400758
759 if (device->grab_surface == surface) {
760 device->grab_surface = NULL;
761 device->grab = 0;
762 }
763 if (device->keyboard_focus == surface)
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -0400764 wlsc_input_device_set_keyboard_focus(device, NULL);
765 if (device->pointer_focus == surface) {
766 focus = pick_surface(device, &sx, &sy);
767 wlsc_input_device_set_pointer_focus(device, focus);
768 fprintf(stderr, "lost pointer focus surface, reverting to %p\n", focus);
769 }
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400770}
771
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400772struct wlsc_input_device *
773wlsc_input_device_create(struct wlsc_compositor *ec)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500774{
Kristian Høgsberg82f6e8a2008-12-19 13:47:53 -0500775 struct wlsc_input_device *device;
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -0500776
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500777 device = malloc(sizeof *device);
778 if (device == NULL)
Kristian Høgsberg890bc052008-12-30 14:31:33 -0500779 return NULL;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500780
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500781 memset(device, 0, sizeof *device);
Kristian Høgsbergfe831a72008-12-21 21:50:23 -0500782 device->base.interface = &wl_input_device_interface;
Kristian Høgsbergb3131d92008-12-24 19:30:25 -0500783 device->base.implementation = NULL;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500784 wl_display_add_object(ec->wl_display, &device->base);
Kristian Høgsbergb3131d92008-12-24 19:30:25 -0500785 wl_display_add_global(ec->wl_display, &device->base, NULL);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500786 device->x = 100;
787 device->y = 100;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500788 device->ec = ec;
789
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400790 device->listener.func = handle_surface_destroy;
791 wl_list_insert(ec->surface_destroy_listener_list.prev,
792 &device->listener.link);
Kristian Høgsbergc492b482008-12-12 12:00:02 -0500793 wl_list_insert(ec->input_device_list.prev, &device->link);
Kristian Høgsberg890bc052008-12-30 14:31:33 -0500794
795 return device;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -0500796}
797
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500798static void
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400799wlsc_output_post_geometry(struct wl_client *client, struct wl_object *global)
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -0500800{
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500801 struct wlsc_output *output =
802 container_of(global, struct wlsc_output, base);
803
804 wl_client_post_event(client, global,
805 WL_OUTPUT_GEOMETRY,
806 output->width, output->height);
807}
808
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400809static const char vertex_shader[] =
810 "uniform mat4 proj;\n"
811 "attribute vec4 position;\n"
812 "attribute vec2 texcoord;\n"
813 "varying vec2 v_texcoord;\n"
814 "void main()\n"
815 "{\n"
816 " gl_Position = proj * position;\n"
817 " v_texcoord = texcoord;\n"
818 "}\n";
819
820static const char fragment_shader[] =
821 /* "precision mediump float;\n" */
822 "varying vec2 v_texcoord;\n"
823 "uniform sampler2D tex;\n"
824 "void main()\n"
825 "{\n"
826 " gl_FragColor = texture2D(tex, v_texcoord)\n;"
827 "}\n";
828
829static void
830init_shaders(struct wlsc_compositor *ec)
831{
832 GLuint v, f, program;
833 const char *p;
834 char msg[512];
835 GLfloat vertices[4 * 5];
836
837 p = vertex_shader;
838 v = glCreateShader(GL_VERTEX_SHADER);
839 glShaderSource(v, 1, &p, NULL);
840 glCompileShader(v);
841 glGetShaderInfoLog(v, sizeof msg, NULL, msg);
842 printf("vertex shader info: %s\n", msg);
843
844 p = fragment_shader;
845 f = glCreateShader(GL_FRAGMENT_SHADER);
846 glShaderSource(f, 1, &p, NULL);
847 glCompileShader(f);
848 glGetShaderInfoLog(f, sizeof msg, NULL, msg);
849 printf("fragment shader info: %s\n", msg);
850
851 program = glCreateProgram();
852 glAttachShader(program, v);
853 glAttachShader(program, f);
854 glBindAttribLocation(program, 0, "position");
855 glBindAttribLocation(program, 1, "texcoord");
856
857 glLinkProgram(program);
858 glGetProgramInfoLog(program, sizeof msg, NULL, msg);
859 printf("info: %s\n", msg);
860
861 glUseProgram(program);
862 ec->proj_uniform = glGetUniformLocation(program, "proj");
863 ec->tex_uniform = glGetUniformLocation(program, "tex");
864
865 vertices[ 0] = 0.0;
866 vertices[ 1] = 0.0;
867 vertices[ 2] = 0.0;
868 vertices[ 3] = 0.0;
869 vertices[ 4] = 0.0;
870
871 vertices[ 5] = 0.0;
872 vertices[ 6] = 1.0;
873 vertices[ 7] = 0.0;
874 vertices[ 8] = 0.0;
875 vertices[ 9] = 1.0;
876
877 vertices[10] = 1.0;
878 vertices[11] = 0.0;
879 vertices[12] = 0.0;
880 vertices[13] = 1.0;
881 vertices[14] = 0.0;
882
883 vertices[15] = 1.0;
884 vertices[16] = 1.0;
885 vertices[17] = 0.0;
886 vertices[18] = 1.0;
887 vertices[19] = 1.0;
888
889 glGenBuffers(1, &ec->vbo);
890 glBindBuffer(GL_ARRAY_BUFFER, ec->vbo);
891 glBufferData(GL_ARRAY_BUFFER, sizeof vertices, vertices, GL_STATIC_DRAW);
892}
893
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500894static const struct wl_interface visual_interface = {
895 "visual", 1,
896};
897
898static void
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500899add_visuals(struct wlsc_compositor *ec)
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500900{
901 ec->argb_visual.base.interface = &visual_interface;
902 ec->argb_visual.base.implementation = NULL;
903 wl_display_add_object(ec->wl_display, &ec->argb_visual.base);
Kristian Høgsbergee02ca62008-12-21 23:37:12 -0500904 wl_display_add_global(ec->wl_display, &ec->argb_visual.base, NULL);
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500905
906 ec->premultiplied_argb_visual.base.interface = &visual_interface;
907 ec->premultiplied_argb_visual.base.implementation = NULL;
908 wl_display_add_object(ec->wl_display,
909 &ec->premultiplied_argb_visual.base);
910 wl_display_add_global(ec->wl_display,
Kristian Høgsbergee02ca62008-12-21 23:37:12 -0500911 &ec->premultiplied_argb_visual.base, NULL);
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500912
913 ec->rgb_visual.base.interface = &visual_interface;
914 ec->rgb_visual.base.implementation = NULL;
915 wl_display_add_object(ec->wl_display, &ec->rgb_visual.base);
Kristian Høgsbergee02ca62008-12-21 23:37:12 -0500916 wl_display_add_global(ec->wl_display, &ec->rgb_visual.base, NULL);
917}
918
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500919static struct wlsc_compositor *
920wlsc_compositor_create(struct wl_display *display)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400921{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500922 struct wlsc_compositor *ec;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500923 struct wl_event_loop *loop;
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400924 struct wlsc_output *output;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400925
926 ec = malloc(sizeof *ec);
927 if (ec == NULL)
928 return NULL;
929
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500930 memset(ec, 0, sizeof *ec);
Kristian Høgsbergf9212892008-10-11 18:40:23 -0400931 ec->wl_display = display;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400932
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500933 wl_display_set_compositor(display, &ec->base, &compositor_interface);
Kristian Høgsbergee02ca62008-12-21 23:37:12 -0500934
Kristian Høgsbergde31d5c2008-12-18 17:55:33 -0500935 add_visuals(ec);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500936
Kristian Høgsberg201a9042008-12-10 00:40:50 -0500937 wl_list_init(&ec->surface_list);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500938 wl_list_init(&ec->input_device_list);
939 wl_list_init(&ec->output_list);
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400940 wl_list_init(&ec->surface_destroy_listener_list);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400941
942 screenshooter_create(ec);
943
944 if (wlsc_compositor_init_drm(ec) < 0) {
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500945 fprintf(stderr, "failed to initialize devices\n");
946 return NULL;
947 }
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500948
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400949 /* Create the pointer and background surfaces now that we have
950 * a current EGL context. */
951 ec->input_device->sprite =
952 pointer_create(ec,
953 ec->input_device->x,
954 ec->input_device->y, 64, 64);
955 wl_list_for_each(output, &ec->output_list, link) {
956 output->background = background_create(output,
957 option_background);
958
959 wlsc_matrix_init(&output->matrix);
960
961 wlsc_matrix_translate(&output->matrix,
962 -output->x - output->width / 2.0,
963 -output->y - output->height / 2.0, 0);
964 wlsc_matrix_scale(&output->matrix,
965 2.0 / output->width, 2.0 / output->height, 1);
966 output->base.interface = &wl_output_interface;
967 wl_display_add_object(ec->wl_display, &output->base);
968 wl_display_add_global(ec->wl_display, &output->base,
969 wlsc_output_post_geometry);
970 }
971
972 glGenFramebuffers(1, &ec->fbo);
973 glBindFramebuffer(GL_FRAMEBUFFER, ec->fbo);
974 glActiveTexture(GL_TEXTURE0);
975 init_shaders(ec);
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -0500976
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500977 loop = wl_display_get_event_loop(ec->wl_display);
Kristian Høgsberg4a298902008-11-28 18:35:25 -0500978 ec->timer_source = wl_event_loop_add_timer(loop, repaint, ec);
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400979 wlsc_compositor_schedule_repaint(ec);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400980
Kristian Høgsberg122912c2008-12-05 11:13:50 -0500981 return ec;
982}
983
984/* The plan here is to generate a random anonymous socket name and
985 * advertise that through a service on the session dbus.
986 */
987static const char socket_name[] = "\0wayland";
988
989int main(int argc, char *argv[])
990{
991 struct wl_display *display;
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500992 struct wlsc_compositor *ec;
Kristian Høgsbergd6531262008-12-12 11:06:18 -0500993 GError *error = NULL;
994 GOptionContext *context;
995
996 context = g_option_context_new(NULL);
997 g_option_context_add_main_entries(context, option_entries, "Wayland");
998 if (!g_option_context_parse(context, &argc, &argv, &error)) {
999 fprintf(stderr, "option parsing failed: %s\n", error->message);
1000 exit(EXIT_FAILURE);
1001 }
Kristian Høgsberg122912c2008-12-05 11:13:50 -05001002
1003 display = wl_display_create();
1004
Kristian Høgsberg8e438622009-01-26 23:07:00 -05001005 ec = wlsc_compositor_create(display);
Kristian Høgsberg841883b2008-12-05 11:19:56 -05001006 if (ec == NULL) {
1007 fprintf(stderr, "failed to create compositor\n");
1008 exit(EXIT_FAILURE);
1009 }
1010
Kristian Høgsbergdc0f3552008-12-07 15:22:22 -05001011 if (wl_display_add_socket(display, socket_name, sizeof socket_name)) {
Kristian Høgsberg122912c2008-12-05 11:13:50 -05001012 fprintf(stderr, "failed to add socket: %m\n");
1013 exit(EXIT_FAILURE);
1014 }
1015
1016 wl_display_run(display);
1017
1018 return 0;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001019}