Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 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 | |
Andrew Wedgbury | 9cd661e | 2014-04-07 12:40:35 +0100 | [diff] [blame] | 23 | #include "config.h" |
| 24 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 25 | #include <stdio.h> |
| 26 | #include <stdlib.h> |
| 27 | #include <string.h> |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 28 | #include <stdbool.h> |
| 29 | #include <math.h> |
| 30 | #include <assert.h> |
Pekka Paalanen | 88e60fc | 2011-12-13 12:09:09 +0200 | [diff] [blame] | 31 | #include <signal.h> |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 32 | |
Ander Conselvan de Oliveira | 57e0ce1 | 2012-06-26 17:09:11 +0300 | [diff] [blame] | 33 | #include <linux/input.h> |
| 34 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 35 | #include <wayland-client.h> |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 36 | #include <wayland-egl.h> |
Kristian Høgsberg | 191e0ee | 2012-10-29 17:41:46 -0400 | [diff] [blame] | 37 | #include <wayland-cursor.h> |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 38 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 39 | #include <GLES2/gl2.h> |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 40 | #include <EGL/egl.h> |
Kristian Høgsberg | 9e885d4 | 2013-05-08 11:37:28 -0400 | [diff] [blame] | 41 | #include <EGL/eglext.h> |
| 42 | |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 43 | #include "xdg-shell-client-protocol.h" |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 44 | #include <sys/types.h> |
| 45 | #include <unistd.h> |
| 46 | #include "protocol/ivi-application-client-protocol.h" |
| 47 | #define IVI_SURFACE_ID 9000 |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 48 | |
Jonny Lamb | 51a7ae5 | 2015-03-20 15:26:51 +0100 | [diff] [blame] | 49 | #include "../shared/platform.h" |
| 50 | |
Kristian Høgsberg | 9e885d4 | 2013-05-08 11:37:28 -0400 | [diff] [blame] | 51 | #ifndef EGL_EXT_swap_buffers_with_damage |
| 52 | #define EGL_EXT_swap_buffers_with_damage 1 |
| 53 | typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects); |
| 54 | #endif |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 55 | |
Kristian Høgsberg | 7778743 | 2013-08-22 12:16:51 -0700 | [diff] [blame] | 56 | #ifndef EGL_EXT_buffer_age |
| 57 | #define EGL_EXT_buffer_age 1 |
| 58 | #define EGL_BUFFER_AGE_EXT 0x313D |
| 59 | #endif |
| 60 | |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 61 | struct window; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 62 | struct seat; |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 63 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 64 | struct display { |
| 65 | struct wl_display *display; |
Kristian Høgsberg | fa80e11 | 2012-10-10 21:34:26 -0400 | [diff] [blame] | 66 | struct wl_registry *registry; |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 67 | struct wl_compositor *compositor; |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 68 | struct xdg_shell *shell; |
Kristian Høgsberg | b84108d | 2012-05-16 16:16:19 -0400 | [diff] [blame] | 69 | struct wl_seat *seat; |
| 70 | struct wl_pointer *pointer; |
Rusty Lynch | 1084da5 | 2013-08-15 09:10:08 -0700 | [diff] [blame] | 71 | struct wl_touch *touch; |
Ander Conselvan de Oliveira | 69f9840 | 2012-07-27 17:18:13 +0300 | [diff] [blame] | 72 | struct wl_keyboard *keyboard; |
Kristian Høgsberg | 191e0ee | 2012-10-29 17:41:46 -0400 | [diff] [blame] | 73 | struct wl_shm *shm; |
| 74 | struct wl_cursor_theme *cursor_theme; |
| 75 | struct wl_cursor *default_cursor; |
| 76 | struct wl_surface *cursor_surface; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 77 | struct { |
| 78 | EGLDisplay dpy; |
| 79 | EGLContext ctx; |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 80 | EGLConfig conf; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 81 | } egl; |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 82 | struct window *window; |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 83 | struct ivi_application *ivi_application; |
Kristian Høgsberg | 9e885d4 | 2013-05-08 11:37:28 -0400 | [diff] [blame] | 84 | |
| 85 | PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC swap_buffers_with_damage; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 86 | }; |
| 87 | |
Ander Conselvan de Oliveira | 69f9840 | 2012-07-27 17:18:13 +0300 | [diff] [blame] | 88 | struct geometry { |
| 89 | int width, height; |
| 90 | }; |
| 91 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 92 | struct window { |
| 93 | struct display *display; |
Scott Moreau | 1ee53e7 | 2012-08-30 14:44:15 -0600 | [diff] [blame] | 94 | struct geometry geometry, window_size; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 95 | struct { |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 96 | GLuint rotation_uniform; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 97 | GLuint pos; |
| 98 | GLuint col; |
| 99 | } gl; |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 100 | |
Kristian Høgsberg | deb3222 | 2013-12-06 22:02:45 -0800 | [diff] [blame] | 101 | uint32_t benchmark_time, frames; |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 102 | struct wl_egl_window *native; |
| 103 | struct wl_surface *surface; |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 104 | struct xdg_surface *xdg_surface; |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 105 | struct ivi_surface *ivi_surface; |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 106 | EGLSurface egl_surface; |
Pekka Paalanen | 2c2c106 | 2011-12-13 14:50:25 +0200 | [diff] [blame] | 107 | struct wl_callback *callback; |
Jasper St. Pierre | 8c6aa45 | 2014-02-08 18:29:49 -0500 | [diff] [blame] | 108 | int fullscreen, opaque, buffer_size, frame_sync; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 109 | }; |
| 110 | |
| 111 | static const char *vert_shader_text = |
| 112 | "uniform mat4 rotation;\n" |
| 113 | "attribute vec4 pos;\n" |
| 114 | "attribute vec4 color;\n" |
| 115 | "varying vec4 v_color;\n" |
| 116 | "void main() {\n" |
| 117 | " gl_Position = rotation * pos;\n" |
| 118 | " v_color = color;\n" |
| 119 | "}\n"; |
| 120 | |
| 121 | static const char *frag_shader_text = |
Kristian Høgsberg | 1a11fac | 2011-01-14 20:39:21 -0500 | [diff] [blame] | 122 | "precision mediump float;\n" |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 123 | "varying vec4 v_color;\n" |
| 124 | "void main() {\n" |
| 125 | " gl_FragColor = v_color;\n" |
| 126 | "}\n"; |
| 127 | |
Kristian Høgsberg | 321e8b7 | 2012-07-30 15:40:57 -0400 | [diff] [blame] | 128 | static int running = 1; |
| 129 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 130 | static void |
Kristian Høgsberg | 78fe753 | 2013-10-15 22:03:31 -0700 | [diff] [blame] | 131 | init_egl(struct display *display, struct window *window) |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 132 | { |
Kristian Høgsberg | 1a11fac | 2011-01-14 20:39:21 -0500 | [diff] [blame] | 133 | static const EGLint context_attribs[] = { |
| 134 | EGL_CONTEXT_CLIENT_VERSION, 2, |
| 135 | EGL_NONE |
| 136 | }; |
Kristian Høgsberg | 9e885d4 | 2013-05-08 11:37:28 -0400 | [diff] [blame] | 137 | const char *extensions; |
Kristian Høgsberg | 1a11fac | 2011-01-14 20:39:21 -0500 | [diff] [blame] | 138 | |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 139 | EGLint config_attribs[] = { |
Kristian Høgsberg | 8e81df4 | 2012-01-11 14:24:46 -0500 | [diff] [blame] | 140 | EGL_SURFACE_TYPE, EGL_WINDOW_BIT, |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 141 | EGL_RED_SIZE, 1, |
| 142 | EGL_GREEN_SIZE, 1, |
| 143 | EGL_BLUE_SIZE, 1, |
Arnaud Vrac | 488b7cd | 2014-08-25 20:56:48 +0200 | [diff] [blame] | 144 | EGL_ALPHA_SIZE, 1, |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 145 | EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, |
| 146 | EGL_NONE |
| 147 | }; |
| 148 | |
Kristian Høgsberg | 78fe753 | 2013-10-15 22:03:31 -0700 | [diff] [blame] | 149 | EGLint major, minor, n, count, i, size; |
| 150 | EGLConfig *configs; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 151 | EGLBoolean ret; |
| 152 | |
Kristian Høgsberg | 78fe753 | 2013-10-15 22:03:31 -0700 | [diff] [blame] | 153 | if (window->opaque || window->buffer_size == 16) |
Kristian Høgsberg | 45ce988 | 2012-08-03 15:27:14 -0400 | [diff] [blame] | 154 | config_attribs[9] = 0; |
| 155 | |
Jonny Lamb | 51a7ae5 | 2015-03-20 15:26:51 +0100 | [diff] [blame] | 156 | display->egl.dpy = |
| 157 | weston_platform_get_egl_display(EGL_PLATFORM_WAYLAND_KHR, |
| 158 | display->display, NULL); |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 159 | assert(display->egl.dpy); |
| 160 | |
| 161 | ret = eglInitialize(display->egl.dpy, &major, &minor); |
| 162 | assert(ret == EGL_TRUE); |
Kristian Høgsberg | 1a11fac | 2011-01-14 20:39:21 -0500 | [diff] [blame] | 163 | ret = eglBindAPI(EGL_OPENGL_ES_API); |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 164 | assert(ret == EGL_TRUE); |
| 165 | |
Kristian Høgsberg | 78fe753 | 2013-10-15 22:03:31 -0700 | [diff] [blame] | 166 | if (!eglGetConfigs(display->egl.dpy, NULL, 0, &count) || count < 1) |
| 167 | assert(0); |
| 168 | |
| 169 | configs = calloc(count, sizeof *configs); |
| 170 | assert(configs); |
| 171 | |
Pekka Paalanen | b79b635 | 2012-06-12 17:42:24 +0300 | [diff] [blame] | 172 | ret = eglChooseConfig(display->egl.dpy, config_attribs, |
Kristian Høgsberg | 78fe753 | 2013-10-15 22:03:31 -0700 | [diff] [blame] | 173 | configs, count, &n); |
| 174 | assert(ret && n >= 1); |
| 175 | |
| 176 | for (i = 0; i < n; i++) { |
| 177 | eglGetConfigAttrib(display->egl.dpy, |
| 178 | configs[i], EGL_BUFFER_SIZE, &size); |
| 179 | if (window->buffer_size == size) { |
| 180 | display->egl.conf = configs[i]; |
| 181 | break; |
| 182 | } |
| 183 | } |
| 184 | free(configs); |
| 185 | if (display->egl.conf == NULL) { |
| 186 | fprintf(stderr, "did not find config with buffer size %d\n", |
| 187 | window->buffer_size); |
| 188 | exit(EXIT_FAILURE); |
| 189 | } |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 190 | |
| 191 | display->egl.ctx = eglCreateContext(display->egl.dpy, |
| 192 | display->egl.conf, |
Kristian Høgsberg | 1a11fac | 2011-01-14 20:39:21 -0500 | [diff] [blame] | 193 | EGL_NO_CONTEXT, context_attribs); |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 194 | assert(display->egl.ctx); |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 195 | |
Kristian Høgsberg | 9e885d4 | 2013-05-08 11:37:28 -0400 | [diff] [blame] | 196 | display->swap_buffers_with_damage = NULL; |
| 197 | extensions = eglQueryString(display->egl.dpy, EGL_EXTENSIONS); |
| 198 | if (extensions && |
| 199 | strstr(extensions, "EGL_EXT_swap_buffers_with_damage") && |
| 200 | strstr(extensions, "EGL_EXT_buffer_age")) |
| 201 | display->swap_buffers_with_damage = |
| 202 | (PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC) |
| 203 | eglGetProcAddress("eglSwapBuffersWithDamageEXT"); |
| 204 | |
| 205 | if (display->swap_buffers_with_damage) |
| 206 | printf("has EGL_EXT_buffer_age and EGL_EXT_swap_buffers_with_damage\n"); |
| 207 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 208 | } |
| 209 | |
Pekka Paalanen | 2c2c106 | 2011-12-13 14:50:25 +0200 | [diff] [blame] | 210 | static void |
| 211 | fini_egl(struct display *display) |
| 212 | { |
Pekka Paalanen | 2c2c106 | 2011-12-13 14:50:25 +0200 | [diff] [blame] | 213 | eglTerminate(display->egl.dpy); |
| 214 | eglReleaseThread(); |
| 215 | } |
| 216 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 217 | static GLuint |
| 218 | create_shader(struct window *window, const char *source, GLenum shader_type) |
| 219 | { |
| 220 | GLuint shader; |
| 221 | GLint status; |
| 222 | |
| 223 | shader = glCreateShader(shader_type); |
| 224 | assert(shader != 0); |
| 225 | |
| 226 | glShaderSource(shader, 1, (const char **) &source, NULL); |
| 227 | glCompileShader(shader); |
| 228 | |
| 229 | glGetShaderiv(shader, GL_COMPILE_STATUS, &status); |
| 230 | if (!status) { |
| 231 | char log[1000]; |
| 232 | GLsizei len; |
| 233 | glGetShaderInfoLog(shader, 1000, &len, log); |
| 234 | fprintf(stderr, "Error: compiling %s: %*s\n", |
| 235 | shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment", |
| 236 | len, log); |
| 237 | exit(1); |
| 238 | } |
| 239 | |
| 240 | return shader; |
| 241 | } |
| 242 | |
| 243 | static void |
| 244 | init_gl(struct window *window) |
| 245 | { |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 246 | GLuint frag, vert; |
Scott Moreau | 3ea23d0 | 2012-06-13 17:42:21 -0600 | [diff] [blame] | 247 | GLuint program; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 248 | GLint status; |
| 249 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 250 | frag = create_shader(window, frag_shader_text, GL_FRAGMENT_SHADER); |
| 251 | vert = create_shader(window, vert_shader_text, GL_VERTEX_SHADER); |
| 252 | |
Scott Moreau | 3ea23d0 | 2012-06-13 17:42:21 -0600 | [diff] [blame] | 253 | program = glCreateProgram(); |
| 254 | glAttachShader(program, frag); |
| 255 | glAttachShader(program, vert); |
| 256 | glLinkProgram(program); |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 257 | |
Scott Moreau | 3ea23d0 | 2012-06-13 17:42:21 -0600 | [diff] [blame] | 258 | glGetProgramiv(program, GL_LINK_STATUS, &status); |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 259 | if (!status) { |
| 260 | char log[1000]; |
| 261 | GLsizei len; |
Scott Moreau | 3ea23d0 | 2012-06-13 17:42:21 -0600 | [diff] [blame] | 262 | glGetProgramInfoLog(program, 1000, &len, log); |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 263 | fprintf(stderr, "Error: linking:\n%*s\n", len, log); |
| 264 | exit(1); |
| 265 | } |
| 266 | |
Scott Moreau | 3ea23d0 | 2012-06-13 17:42:21 -0600 | [diff] [blame] | 267 | glUseProgram(program); |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 268 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 269 | window->gl.pos = 0; |
Scott Moreau | 3ea23d0 | 2012-06-13 17:42:21 -0600 | [diff] [blame] | 270 | window->gl.col = 1; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 271 | |
Scott Moreau | 3ea23d0 | 2012-06-13 17:42:21 -0600 | [diff] [blame] | 272 | glBindAttribLocation(program, window->gl.pos, "pos"); |
| 273 | glBindAttribLocation(program, window->gl.col, "color"); |
| 274 | glLinkProgram(program); |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 275 | |
| 276 | window->gl.rotation_uniform = |
Scott Moreau | 3ea23d0 | 2012-06-13 17:42:21 -0600 | [diff] [blame] | 277 | glGetUniformLocation(program, "rotation"); |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 278 | } |
| 279 | |
| 280 | static void |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 281 | handle_surface_configure(void *data, struct xdg_surface *surface, |
Jasper St. Pierre | ab2c108 | 2014-04-10 10:41:46 -0700 | [diff] [blame] | 282 | int32_t width, int32_t height, |
| 283 | struct wl_array *states, uint32_t serial) |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 284 | { |
| 285 | struct window *window = data; |
Jasper St. Pierre | ab2c108 | 2014-04-10 10:41:46 -0700 | [diff] [blame] | 286 | uint32_t *p; |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 287 | |
Jasper St. Pierre | ab2c108 | 2014-04-10 10:41:46 -0700 | [diff] [blame] | 288 | window->fullscreen = 0; |
| 289 | wl_array_for_each(p, states) { |
| 290 | uint32_t state = *p; |
| 291 | switch (state) { |
| 292 | case XDG_SURFACE_STATE_FULLSCREEN: |
| 293 | window->fullscreen = 1; |
| 294 | break; |
| 295 | } |
Jasper St. Pierre | 8c6aa45 | 2014-02-08 18:29:49 -0500 | [diff] [blame] | 296 | } |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 297 | |
Jasper St. Pierre | ab2c108 | 2014-04-10 10:41:46 -0700 | [diff] [blame] | 298 | if (width > 0 && height > 0) { |
| 299 | if (!window->fullscreen) { |
| 300 | window->window_size.width = width; |
| 301 | window->window_size.height = height; |
| 302 | } |
| 303 | window->geometry.width = width; |
| 304 | window->geometry.height = height; |
| 305 | } else if (!window->fullscreen) { |
| 306 | window->geometry = window->window_size; |
| 307 | } |
| 308 | |
| 309 | if (window->native) |
| 310 | wl_egl_window_resize(window->native, |
| 311 | window->geometry.width, |
| 312 | window->geometry.height, 0, 0); |
| 313 | |
| 314 | xdg_surface_ack_configure(surface, serial); |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 315 | } |
| 316 | |
| 317 | static void |
Jasper St. Pierre | a0d8a30 | 2014-02-08 18:31:10 -0500 | [diff] [blame] | 318 | handle_surface_delete(void *data, struct xdg_surface *xdg_surface) |
| 319 | { |
| 320 | running = 0; |
| 321 | } |
| 322 | |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 323 | static const struct xdg_surface_listener xdg_surface_listener = { |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 324 | handle_surface_configure, |
Jasper St. Pierre | a0d8a30 | 2014-02-08 18:31:10 -0500 | [diff] [blame] | 325 | handle_surface_delete, |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 326 | }; |
| 327 | |
| 328 | static void |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 329 | handle_ivi_surface_configure(void *data, struct ivi_surface *ivi_surface, |
| 330 | int32_t width, int32_t height) |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 331 | { |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 332 | struct window *window = data; |
| 333 | |
| 334 | wl_egl_window_resize(window->native, width, height, 0, 0); |
| 335 | |
| 336 | window->geometry.width = width; |
| 337 | window->geometry.height = height; |
| 338 | |
| 339 | if (!window->fullscreen) |
| 340 | window->window_size = window->geometry; |
| 341 | } |
| 342 | |
| 343 | static const struct ivi_surface_listener ivi_surface_listener = { |
| 344 | handle_ivi_surface_configure, |
| 345 | }; |
| 346 | |
| 347 | static void |
| 348 | create_xdg_surface(struct window *window, struct display *display) |
| 349 | { |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 350 | window->xdg_surface = xdg_shell_get_xdg_surface(display->shell, |
| 351 | window->surface); |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 352 | |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 353 | xdg_surface_add_listener(window->xdg_surface, |
| 354 | &xdg_surface_listener, window); |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 355 | |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 356 | xdg_surface_set_title(window->xdg_surface, "simple-egl"); |
| 357 | } |
| 358 | |
| 359 | static void |
| 360 | create_ivi_surface(struct window *window, struct display *display) |
| 361 | { |
| 362 | uint32_t id_ivisurf = IVI_SURFACE_ID + (uint32_t)getpid(); |
| 363 | window->ivi_surface = |
| 364 | ivi_application_surface_create(display->ivi_application, |
| 365 | id_ivisurf, window->surface); |
| 366 | |
| 367 | if (window->ivi_surface == NULL) { |
| 368 | fprintf(stderr, "Failed to create ivi_client_surface\n"); |
| 369 | abort(); |
| 370 | } |
| 371 | |
| 372 | ivi_surface_add_listener(window->ivi_surface, |
| 373 | &ivi_surface_listener, window); |
| 374 | } |
| 375 | |
| 376 | static void |
| 377 | create_surface(struct window *window) |
| 378 | { |
| 379 | struct display *display = window->display; |
| 380 | EGLBoolean ret; |
| 381 | |
| 382 | window->surface = wl_compositor_create_surface(display->compositor); |
| 383 | |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 384 | window->native = |
Kristian Høgsberg | 91342c6 | 2011-04-14 14:44:58 -0400 | [diff] [blame] | 385 | wl_egl_window_create(window->surface, |
Jasper St. Pierre | ab2c108 | 2014-04-10 10:41:46 -0700 | [diff] [blame] | 386 | window->geometry.width, |
| 387 | window->geometry.height); |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 388 | window->egl_surface = |
Jonny Lamb | 4bdcb57 | 2015-03-20 15:26:53 +0100 | [diff] [blame^] | 389 | weston_platform_create_egl_window(display->egl.dpy, |
| 390 | display->egl.conf, |
| 391 | window->native, NULL); |
| 392 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 393 | |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 394 | if (display->shell) { |
| 395 | create_xdg_surface(window, display); |
| 396 | } else if (display->ivi_application ) { |
| 397 | create_ivi_surface(window, display); |
| 398 | } else { |
| 399 | assert(0); |
| 400 | } |
Scott Moreau | 01a9f1b | 2012-10-07 08:56:30 -0600 | [diff] [blame] | 401 | |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 402 | ret = eglMakeCurrent(window->display->egl.dpy, window->egl_surface, |
| 403 | window->egl_surface, window->display->egl.ctx); |
| 404 | assert(ret == EGL_TRUE); |
Ander Conselvan de Oliveira | 69f9840 | 2012-07-27 17:18:13 +0300 | [diff] [blame] | 405 | |
Kristian Høgsberg | 1e65840 | 2013-12-07 22:25:56 -0800 | [diff] [blame] | 406 | if (!window->frame_sync) |
| 407 | eglSwapInterval(display->egl.dpy, 0); |
| 408 | |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 409 | if (!display->shell) |
| 410 | return; |
| 411 | |
Jasper St. Pierre | ab2c108 | 2014-04-10 10:41:46 -0700 | [diff] [blame] | 412 | if (window->fullscreen) |
| 413 | xdg_surface_set_fullscreen(window->xdg_surface, NULL); |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 414 | } |
| 415 | |
Pekka Paalanen | 2c2c106 | 2011-12-13 14:50:25 +0200 | [diff] [blame] | 416 | static void |
| 417 | destroy_surface(struct window *window) |
| 418 | { |
Yeh, Sinclair | 952e6df | 2013-04-19 17:49:12 +0000 | [diff] [blame] | 419 | /* Required, otherwise segfault in egl_dri2.c: dri2_make_current() |
| 420 | * on eglReleaseThread(). */ |
| 421 | eglMakeCurrent(window->display->egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, |
| 422 | EGL_NO_CONTEXT); |
| 423 | |
| 424 | eglDestroySurface(window->display->egl.dpy, window->egl_surface); |
Pekka Paalanen | 2c2c106 | 2011-12-13 14:50:25 +0200 | [diff] [blame] | 425 | wl_egl_window_destroy(window->native); |
| 426 | |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 427 | if (window->xdg_surface) |
| 428 | xdg_surface_destroy(window->xdg_surface); |
| 429 | if (window->display->ivi_application) |
| 430 | ivi_surface_destroy(window->ivi_surface); |
Pekka Paalanen | 2c2c106 | 2011-12-13 14:50:25 +0200 | [diff] [blame] | 431 | wl_surface_destroy(window->surface); |
| 432 | |
| 433 | if (window->callback) |
| 434 | wl_callback_destroy(window->callback); |
| 435 | } |
| 436 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 437 | static void |
Kristian Høgsberg | 3341820 | 2011-08-16 23:01:28 -0400 | [diff] [blame] | 438 | redraw(void *data, struct wl_callback *callback, uint32_t time) |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 439 | { |
| 440 | struct window *window = data; |
Kristian Høgsberg | 9e885d4 | 2013-05-08 11:37:28 -0400 | [diff] [blame] | 441 | struct display *display = window->display; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 442 | static const GLfloat verts[3][2] = { |
| 443 | { -0.5, -0.5 }, |
| 444 | { 0.5, -0.5 }, |
| 445 | { 0, 0.5 } |
| 446 | }; |
| 447 | static const GLfloat colors[3][3] = { |
| 448 | { 1, 0, 0 }, |
| 449 | { 0, 1, 0 }, |
| 450 | { 0, 0, 1 } |
| 451 | }; |
| 452 | GLfloat angle; |
| 453 | GLfloat rotation[4][4] = { |
| 454 | { 1, 0, 0, 0 }, |
| 455 | { 0, 1, 0, 0 }, |
| 456 | { 0, 0, 1, 0 }, |
| 457 | { 0, 0, 0, 1 } |
| 458 | }; |
Jonas Ådahl | 82fced4 | 2014-01-03 19:46:50 +0100 | [diff] [blame] | 459 | static const uint32_t speed_div = 5, benchmark_interval = 5; |
Kristian Høgsberg | 45ce988 | 2012-08-03 15:27:14 -0400 | [diff] [blame] | 460 | struct wl_region *region; |
Kristian Høgsberg | 9e885d4 | 2013-05-08 11:37:28 -0400 | [diff] [blame] | 461 | EGLint rect[4]; |
| 462 | EGLint buffer_age = 0; |
Kristian Høgsberg | deb3222 | 2013-12-06 22:02:45 -0800 | [diff] [blame] | 463 | struct timeval tv; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 464 | |
Scott Moreau | 7e300db | 2012-08-31 03:18:15 -0600 | [diff] [blame] | 465 | assert(window->callback == callback); |
| 466 | window->callback = NULL; |
| 467 | |
Ander Conselvan de Oliveira | 69f9840 | 2012-07-27 17:18:13 +0300 | [diff] [blame] | 468 | if (callback) |
| 469 | wl_callback_destroy(callback); |
| 470 | |
Kristian Høgsberg | deb3222 | 2013-12-06 22:02:45 -0800 | [diff] [blame] | 471 | gettimeofday(&tv, NULL); |
| 472 | time = tv.tv_sec * 1000 + tv.tv_usec / 1000; |
| 473 | if (window->frames == 0) |
| 474 | window->benchmark_time = time; |
| 475 | if (time - window->benchmark_time > (benchmark_interval * 1000)) { |
| 476 | printf("%d frames in %d seconds: %f fps\n", |
| 477 | window->frames, |
| 478 | benchmark_interval, |
| 479 | (float) window->frames / benchmark_interval); |
| 480 | window->benchmark_time = time; |
| 481 | window->frames = 0; |
| 482 | } |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 483 | |
Kristian Høgsberg | deb3222 | 2013-12-06 22:02:45 -0800 | [diff] [blame] | 484 | angle = (time / speed_div) % 360 * M_PI / 180.0; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 485 | rotation[0][0] = cos(angle); |
| 486 | rotation[0][2] = sin(angle); |
| 487 | rotation[2][0] = -sin(angle); |
| 488 | rotation[2][2] = cos(angle); |
| 489 | |
Kristian Høgsberg | 9e885d4 | 2013-05-08 11:37:28 -0400 | [diff] [blame] | 490 | if (display->swap_buffers_with_damage) |
| 491 | eglQuerySurface(display->egl.dpy, window->egl_surface, |
| 492 | EGL_BUFFER_AGE_EXT, &buffer_age); |
| 493 | |
Ander Conselvan de Oliveira | 69f9840 | 2012-07-27 17:18:13 +0300 | [diff] [blame] | 494 | glViewport(0, 0, window->geometry.width, window->geometry.height); |
| 495 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 496 | glUniformMatrix4fv(window->gl.rotation_uniform, 1, GL_FALSE, |
| 497 | (GLfloat *) rotation); |
| 498 | |
| 499 | glClearColor(0.0, 0.0, 0.0, 0.5); |
| 500 | glClear(GL_COLOR_BUFFER_BIT); |
| 501 | |
| 502 | glVertexAttribPointer(window->gl.pos, 2, GL_FLOAT, GL_FALSE, 0, verts); |
| 503 | glVertexAttribPointer(window->gl.col, 3, GL_FLOAT, GL_FALSE, 0, colors); |
| 504 | glEnableVertexAttribArray(window->gl.pos); |
| 505 | glEnableVertexAttribArray(window->gl.col); |
| 506 | |
| 507 | glDrawArrays(GL_TRIANGLES, 0, 3); |
| 508 | |
| 509 | glDisableVertexAttribArray(window->gl.pos); |
| 510 | glDisableVertexAttribArray(window->gl.col); |
| 511 | |
Ander Conselvan de Oliveira | d7f282b | 2012-09-10 15:55:53 +0300 | [diff] [blame] | 512 | if (window->opaque || window->fullscreen) { |
Kristian Høgsberg | 45ce988 | 2012-08-03 15:27:14 -0400 | [diff] [blame] | 513 | region = wl_compositor_create_region(window->display->compositor); |
| 514 | wl_region_add(region, 0, 0, |
Ander Conselvan de Oliveira | edce9c2 | 2012-09-07 17:32:16 +0300 | [diff] [blame] | 515 | window->geometry.width, |
| 516 | window->geometry.height); |
Kristian Høgsberg | 45ce988 | 2012-08-03 15:27:14 -0400 | [diff] [blame] | 517 | wl_surface_set_opaque_region(window->surface, region); |
| 518 | wl_region_destroy(region); |
Scott Moreau | 6655e00 | 2012-11-19 14:17:52 -0700 | [diff] [blame] | 519 | } else { |
| 520 | wl_surface_set_opaque_region(window->surface, NULL); |
Kristian Høgsberg | 45ce988 | 2012-08-03 15:27:14 -0400 | [diff] [blame] | 521 | } |
| 522 | |
Kristian Høgsberg | 9e885d4 | 2013-05-08 11:37:28 -0400 | [diff] [blame] | 523 | if (display->swap_buffers_with_damage && buffer_age > 0) { |
| 524 | rect[0] = window->geometry.width / 4 - 1; |
| 525 | rect[1] = window->geometry.height / 4 - 1; |
| 526 | rect[2] = window->geometry.width / 2 + 2; |
| 527 | rect[3] = window->geometry.height / 2 + 2; |
| 528 | display->swap_buffers_with_damage(display->egl.dpy, |
| 529 | window->egl_surface, |
| 530 | rect, 1); |
| 531 | } else { |
| 532 | eglSwapBuffers(display->egl.dpy, window->egl_surface); |
| 533 | } |
Kristian Høgsberg | deb3222 | 2013-12-06 22:02:45 -0800 | [diff] [blame] | 534 | window->frames++; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 535 | } |
| 536 | |
| 537 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 538 | pointer_handle_enter(void *data, struct wl_pointer *pointer, |
| 539 | uint32_t serial, struct wl_surface *surface, |
| 540 | wl_fixed_t sx, wl_fixed_t sy) |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 541 | { |
| 542 | struct display *display = data; |
Kristian Høgsberg | 191e0ee | 2012-10-29 17:41:46 -0400 | [diff] [blame] | 543 | struct wl_buffer *buffer; |
| 544 | struct wl_cursor *cursor = display->default_cursor; |
| 545 | struct wl_cursor_image *image; |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 546 | |
| 547 | if (display->window->fullscreen) |
Ander Conselvan de Oliveira | 37ffc3c | 2012-06-15 17:27:35 +0300 | [diff] [blame] | 548 | wl_pointer_set_cursor(pointer, serial, NULL, 0, 0); |
Kristian Høgsberg | 191e0ee | 2012-10-29 17:41:46 -0400 | [diff] [blame] | 549 | else if (cursor) { |
| 550 | image = display->default_cursor->images[0]; |
| 551 | buffer = wl_cursor_image_get_buffer(image); |
Hardening | 842a36a | 2014-03-18 14:12:50 +0100 | [diff] [blame] | 552 | if (!buffer) |
| 553 | return; |
Kristian Høgsberg | 191e0ee | 2012-10-29 17:41:46 -0400 | [diff] [blame] | 554 | wl_pointer_set_cursor(pointer, serial, |
| 555 | display->cursor_surface, |
| 556 | image->hotspot_x, |
| 557 | image->hotspot_y); |
| 558 | wl_surface_attach(display->cursor_surface, buffer, 0, 0); |
| 559 | wl_surface_damage(display->cursor_surface, 0, 0, |
| 560 | image->width, image->height); |
| 561 | wl_surface_commit(display->cursor_surface); |
| 562 | } |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 563 | } |
| 564 | |
| 565 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 566 | pointer_handle_leave(void *data, struct wl_pointer *pointer, |
| 567 | uint32_t serial, struct wl_surface *surface) |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 568 | { |
| 569 | } |
| 570 | |
| 571 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 572 | pointer_handle_motion(void *data, struct wl_pointer *pointer, |
| 573 | uint32_t time, wl_fixed_t sx, wl_fixed_t sy) |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 574 | { |
| 575 | } |
| 576 | |
| 577 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 578 | pointer_handle_button(void *data, struct wl_pointer *wl_pointer, |
| 579 | uint32_t serial, uint32_t time, uint32_t button, |
| 580 | uint32_t state) |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 581 | { |
Ander Conselvan de Oliveira | 57e0ce1 | 2012-06-26 17:09:11 +0300 | [diff] [blame] | 582 | struct display *display = data; |
| 583 | |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 584 | if (!display->window->xdg_surface) |
| 585 | return; |
| 586 | |
Ander Conselvan de Oliveira | 57e0ce1 | 2012-06-26 17:09:11 +0300 | [diff] [blame] | 587 | if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED) |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 588 | xdg_surface_move(display->window->xdg_surface, |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 589 | display->seat, serial); |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 590 | } |
| 591 | |
| 592 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 593 | pointer_handle_axis(void *data, struct wl_pointer *wl_pointer, |
Daniel Stone | 2fce402 | 2012-05-30 16:32:00 +0100 | [diff] [blame] | 594 | uint32_t time, uint32_t axis, wl_fixed_t value) |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 595 | { |
| 596 | } |
| 597 | |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 598 | static const struct wl_pointer_listener pointer_listener = { |
| 599 | pointer_handle_enter, |
| 600 | pointer_handle_leave, |
| 601 | pointer_handle_motion, |
| 602 | pointer_handle_button, |
| 603 | pointer_handle_axis, |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 604 | }; |
| 605 | |
| 606 | static void |
Rusty Lynch | 1084da5 | 2013-08-15 09:10:08 -0700 | [diff] [blame] | 607 | touch_handle_down(void *data, struct wl_touch *wl_touch, |
| 608 | uint32_t serial, uint32_t time, struct wl_surface *surface, |
| 609 | int32_t id, wl_fixed_t x_w, wl_fixed_t y_w) |
| 610 | { |
| 611 | struct display *d = (struct display *)data; |
| 612 | |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 613 | if (!d->shell) |
| 614 | return; |
| 615 | |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 616 | xdg_surface_move(d->window->xdg_surface, d->seat, serial); |
Rusty Lynch | 1084da5 | 2013-08-15 09:10:08 -0700 | [diff] [blame] | 617 | } |
| 618 | |
| 619 | static void |
| 620 | touch_handle_up(void *data, struct wl_touch *wl_touch, |
| 621 | uint32_t serial, uint32_t time, int32_t id) |
| 622 | { |
| 623 | } |
| 624 | |
| 625 | static void |
| 626 | touch_handle_motion(void *data, struct wl_touch *wl_touch, |
| 627 | uint32_t time, int32_t id, wl_fixed_t x_w, wl_fixed_t y_w) |
| 628 | { |
| 629 | } |
| 630 | |
| 631 | static void |
| 632 | touch_handle_frame(void *data, struct wl_touch *wl_touch) |
| 633 | { |
| 634 | } |
| 635 | |
| 636 | static void |
| 637 | touch_handle_cancel(void *data, struct wl_touch *wl_touch) |
| 638 | { |
| 639 | } |
| 640 | |
| 641 | static const struct wl_touch_listener touch_listener = { |
| 642 | touch_handle_down, |
| 643 | touch_handle_up, |
| 644 | touch_handle_motion, |
| 645 | touch_handle_frame, |
| 646 | touch_handle_cancel, |
| 647 | }; |
| 648 | |
| 649 | static void |
Ander Conselvan de Oliveira | 69f9840 | 2012-07-27 17:18:13 +0300 | [diff] [blame] | 650 | keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard, |
| 651 | uint32_t format, int fd, uint32_t size) |
| 652 | { |
| 653 | } |
| 654 | |
| 655 | static void |
| 656 | keyboard_handle_enter(void *data, struct wl_keyboard *keyboard, |
| 657 | uint32_t serial, struct wl_surface *surface, |
| 658 | struct wl_array *keys) |
| 659 | { |
| 660 | } |
| 661 | |
| 662 | static void |
| 663 | keyboard_handle_leave(void *data, struct wl_keyboard *keyboard, |
| 664 | uint32_t serial, struct wl_surface *surface) |
| 665 | { |
| 666 | } |
| 667 | |
| 668 | static void |
| 669 | keyboard_handle_key(void *data, struct wl_keyboard *keyboard, |
| 670 | uint32_t serial, uint32_t time, uint32_t key, |
| 671 | uint32_t state) |
| 672 | { |
| 673 | struct display *d = data; |
| 674 | |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 675 | if (!d->shell) |
| 676 | return; |
| 677 | |
Jasper St. Pierre | ab2c108 | 2014-04-10 10:41:46 -0700 | [diff] [blame] | 678 | if (key == KEY_F11 && state) { |
| 679 | if (d->window->fullscreen) |
| 680 | xdg_surface_unset_fullscreen(d->window->xdg_surface); |
| 681 | else |
| 682 | xdg_surface_set_fullscreen(d->window->xdg_surface, NULL); |
| 683 | } else if (key == KEY_ESC && state) |
Kristian Høgsberg | 321e8b7 | 2012-07-30 15:40:57 -0400 | [diff] [blame] | 684 | running = 0; |
Ander Conselvan de Oliveira | 69f9840 | 2012-07-27 17:18:13 +0300 | [diff] [blame] | 685 | } |
| 686 | |
| 687 | static void |
| 688 | keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard, |
| 689 | uint32_t serial, uint32_t mods_depressed, |
| 690 | uint32_t mods_latched, uint32_t mods_locked, |
| 691 | uint32_t group) |
| 692 | { |
| 693 | } |
| 694 | |
| 695 | static const struct wl_keyboard_listener keyboard_listener = { |
| 696 | keyboard_handle_keymap, |
| 697 | keyboard_handle_enter, |
| 698 | keyboard_handle_leave, |
| 699 | keyboard_handle_key, |
| 700 | keyboard_handle_modifiers, |
| 701 | }; |
| 702 | |
| 703 | static void |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 704 | seat_handle_capabilities(void *data, struct wl_seat *seat, |
| 705 | enum wl_seat_capability caps) |
| 706 | { |
Kristian Høgsberg | b84108d | 2012-05-16 16:16:19 -0400 | [diff] [blame] | 707 | struct display *d = data; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 708 | |
Kristian Høgsberg | b84108d | 2012-05-16 16:16:19 -0400 | [diff] [blame] | 709 | if ((caps & WL_SEAT_CAPABILITY_POINTER) && !d->pointer) { |
| 710 | d->pointer = wl_seat_get_pointer(seat); |
| 711 | wl_pointer_add_listener(d->pointer, &pointer_listener, d); |
| 712 | } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && d->pointer) { |
| 713 | wl_pointer_destroy(d->pointer); |
| 714 | d->pointer = NULL; |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 715 | } |
Ander Conselvan de Oliveira | 69f9840 | 2012-07-27 17:18:13 +0300 | [diff] [blame] | 716 | |
| 717 | if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !d->keyboard) { |
| 718 | d->keyboard = wl_seat_get_keyboard(seat); |
| 719 | wl_keyboard_add_listener(d->keyboard, &keyboard_listener, d); |
| 720 | } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && d->keyboard) { |
| 721 | wl_keyboard_destroy(d->keyboard); |
| 722 | d->keyboard = NULL; |
| 723 | } |
Rusty Lynch | 1084da5 | 2013-08-15 09:10:08 -0700 | [diff] [blame] | 724 | |
| 725 | if ((caps & WL_SEAT_CAPABILITY_TOUCH) && !d->touch) { |
| 726 | d->touch = wl_seat_get_touch(seat); |
| 727 | wl_touch_set_user_data(d->touch, d); |
| 728 | wl_touch_add_listener(d->touch, &touch_listener, d); |
| 729 | } else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && d->touch) { |
| 730 | wl_touch_destroy(d->touch); |
| 731 | d->touch = NULL; |
| 732 | } |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 733 | } |
| 734 | |
| 735 | static const struct wl_seat_listener seat_listener = { |
| 736 | seat_handle_capabilities, |
| 737 | }; |
| 738 | |
| 739 | static void |
Kristian Høgsberg | 2bff94e | 2014-02-11 12:22:51 -0800 | [diff] [blame] | 740 | xdg_shell_ping(void *data, struct xdg_shell *shell, uint32_t serial) |
| 741 | { |
| 742 | xdg_shell_pong(shell, serial); |
| 743 | } |
| 744 | |
| 745 | static const struct xdg_shell_listener xdg_shell_listener = { |
| 746 | xdg_shell_ping, |
| 747 | }; |
| 748 | |
Jasper St. Pierre | 5ba1e1d | 2015-02-13 14:02:02 +0800 | [diff] [blame] | 749 | #define XDG_VERSION 5 /* The version of xdg-shell that we implement */ |
Kristian Høgsberg | 239902b | 2014-02-11 13:50:08 -0800 | [diff] [blame] | 750 | #ifdef static_assert |
| 751 | static_assert(XDG_VERSION == XDG_SHELL_VERSION_CURRENT, |
| 752 | "Interface version doesn't match implementation version"); |
| 753 | #endif |
| 754 | |
Kristian Høgsberg | 2bff94e | 2014-02-11 12:22:51 -0800 | [diff] [blame] | 755 | static void |
Kristian Høgsberg | fa80e11 | 2012-10-10 21:34:26 -0400 | [diff] [blame] | 756 | registry_handle_global(void *data, struct wl_registry *registry, |
| 757 | uint32_t name, const char *interface, uint32_t version) |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 758 | { |
| 759 | struct display *d = data; |
| 760 | |
Kristian Høgsberg | 8357cd6 | 2011-05-13 13:24:56 -0400 | [diff] [blame] | 761 | if (strcmp(interface, "wl_compositor") == 0) { |
Kristian Høgsberg | f790c79 | 2011-08-19 14:41:57 -0400 | [diff] [blame] | 762 | d->compositor = |
Kristian Høgsberg | fa80e11 | 2012-10-10 21:34:26 -0400 | [diff] [blame] | 763 | wl_registry_bind(registry, name, |
| 764 | &wl_compositor_interface, 1); |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 765 | } else if (strcmp(interface, "xdg_shell") == 0) { |
Kristian Høgsberg | fa80e11 | 2012-10-10 21:34:26 -0400 | [diff] [blame] | 766 | d->shell = wl_registry_bind(registry, name, |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 767 | &xdg_shell_interface, 1); |
Kristian Høgsberg | 2bff94e | 2014-02-11 12:22:51 -0800 | [diff] [blame] | 768 | xdg_shell_add_listener(d->shell, &xdg_shell_listener, d); |
Kristian Høgsberg | 239902b | 2014-02-11 13:50:08 -0800 | [diff] [blame] | 769 | xdg_shell_use_unstable_version(d->shell, XDG_VERSION); |
Daniel Stone | 37816df | 2012-05-16 18:45:18 +0100 | [diff] [blame] | 770 | } else if (strcmp(interface, "wl_seat") == 0) { |
Kristian Høgsberg | fa80e11 | 2012-10-10 21:34:26 -0400 | [diff] [blame] | 771 | d->seat = wl_registry_bind(registry, name, |
| 772 | &wl_seat_interface, 1); |
Kristian Høgsberg | b84108d | 2012-05-16 16:16:19 -0400 | [diff] [blame] | 773 | wl_seat_add_listener(d->seat, &seat_listener, d); |
Kristian Høgsberg | 191e0ee | 2012-10-29 17:41:46 -0400 | [diff] [blame] | 774 | } else if (strcmp(interface, "wl_shm") == 0) { |
| 775 | d->shm = wl_registry_bind(registry, name, |
| 776 | &wl_shm_interface, 1); |
| 777 | d->cursor_theme = wl_cursor_theme_load(NULL, 32, d->shm); |
Hardening | 842a36a | 2014-03-18 14:12:50 +0100 | [diff] [blame] | 778 | if (!d->cursor_theme) { |
| 779 | fprintf(stderr, "unable to load default theme\n"); |
| 780 | return; |
| 781 | } |
Kristian Høgsberg | 191e0ee | 2012-10-29 17:41:46 -0400 | [diff] [blame] | 782 | d->default_cursor = |
| 783 | wl_cursor_theme_get_cursor(d->cursor_theme, "left_ptr"); |
Hardening | 842a36a | 2014-03-18 14:12:50 +0100 | [diff] [blame] | 784 | if (!d->default_cursor) { |
| 785 | fprintf(stderr, "unable to load default left pointer\n"); |
| 786 | // TODO: abort ? |
| 787 | } |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 788 | } else if (strcmp(interface, "ivi_application") == 0) { |
| 789 | d->ivi_application = |
| 790 | wl_registry_bind(registry, name, |
| 791 | &ivi_application_interface, 1); |
Kristian Høgsberg | 8357cd6 | 2011-05-13 13:24:56 -0400 | [diff] [blame] | 792 | } |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 793 | } |
| 794 | |
Pekka Paalanen | 0eab05d | 2013-01-22 14:53:55 +0200 | [diff] [blame] | 795 | static void |
| 796 | registry_handle_global_remove(void *data, struct wl_registry *registry, |
| 797 | uint32_t name) |
| 798 | { |
| 799 | } |
| 800 | |
Kristian Høgsberg | fa80e11 | 2012-10-10 21:34:26 -0400 | [diff] [blame] | 801 | static const struct wl_registry_listener registry_listener = { |
Pekka Paalanen | 0eab05d | 2013-01-22 14:53:55 +0200 | [diff] [blame] | 802 | registry_handle_global, |
| 803 | registry_handle_global_remove |
Kristian Høgsberg | fa80e11 | 2012-10-10 21:34:26 -0400 | [diff] [blame] | 804 | }; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 805 | |
Pekka Paalanen | 88e60fc | 2011-12-13 12:09:09 +0200 | [diff] [blame] | 806 | static void |
| 807 | signal_int(int signum) |
| 808 | { |
| 809 | running = 0; |
| 810 | } |
| 811 | |
Kristian Høgsberg | bcf4864 | 2012-08-03 15:29:08 -0400 | [diff] [blame] | 812 | static void |
| 813 | usage(int error_code) |
| 814 | { |
| 815 | fprintf(stderr, "Usage: simple-egl [OPTIONS]\n\n" |
| 816 | " -f\tRun in fullscreen mode\n" |
| 817 | " -o\tCreate an opaque surface\n" |
Kristian Høgsberg | 78fe753 | 2013-10-15 22:03:31 -0700 | [diff] [blame] | 818 | " -s\tUse a 16 bpp EGL config\n" |
Kristian Høgsberg | 1e65840 | 2013-12-07 22:25:56 -0800 | [diff] [blame] | 819 | " -b\tDon't sync to compositor redraw (eglSwapInterval 0)\n" |
Kristian Høgsberg | bcf4864 | 2012-08-03 15:29:08 -0400 | [diff] [blame] | 820 | " -h\tThis help text\n\n"); |
| 821 | |
| 822 | exit(error_code); |
| 823 | } |
| 824 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 825 | int |
| 826 | main(int argc, char **argv) |
| 827 | { |
Pekka Paalanen | 88e60fc | 2011-12-13 12:09:09 +0200 | [diff] [blame] | 828 | struct sigaction sigint; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 829 | struct display display = { 0 }; |
| 830 | struct window window = { 0 }; |
Kristian Høgsberg | a17f7a1 | 2012-10-16 13:16:10 -0400 | [diff] [blame] | 831 | int i, ret = 0; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 832 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 833 | window.display = &display; |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 834 | display.window = &window; |
Jasper St. Pierre | ab2c108 | 2014-04-10 10:41:46 -0700 | [diff] [blame] | 835 | window.geometry.width = 250; |
| 836 | window.geometry.height = 250; |
| 837 | window.window_size = window.geometry; |
Kristian Høgsberg | 78fe753 | 2013-10-15 22:03:31 -0700 | [diff] [blame] | 838 | window.buffer_size = 32; |
Kristian Høgsberg | 1e65840 | 2013-12-07 22:25:56 -0800 | [diff] [blame] | 839 | window.frame_sync = 1; |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 840 | |
Kristian Høgsberg | 3593f81 | 2012-05-10 20:40:51 -0400 | [diff] [blame] | 841 | for (i = 1; i < argc; i++) { |
| 842 | if (strcmp("-f", argv[i]) == 0) |
| 843 | window.fullscreen = 1; |
Kristian Høgsberg | bcf4864 | 2012-08-03 15:29:08 -0400 | [diff] [blame] | 844 | else if (strcmp("-o", argv[i]) == 0) |
Ander Conselvan de Oliveira | d7f282b | 2012-09-10 15:55:53 +0300 | [diff] [blame] | 845 | window.opaque = 1; |
Kristian Høgsberg | 78fe753 | 2013-10-15 22:03:31 -0700 | [diff] [blame] | 846 | else if (strcmp("-s", argv[i]) == 0) |
| 847 | window.buffer_size = 16; |
Kristian Høgsberg | 1e65840 | 2013-12-07 22:25:56 -0800 | [diff] [blame] | 848 | else if (strcmp("-b", argv[i]) == 0) |
| 849 | window.frame_sync = 0; |
Kristian Høgsberg | bcf4864 | 2012-08-03 15:29:08 -0400 | [diff] [blame] | 850 | else if (strcmp("-h", argv[i]) == 0) |
| 851 | usage(EXIT_SUCCESS); |
| 852 | else |
| 853 | usage(EXIT_FAILURE); |
Kristian Høgsberg | 3593f81 | 2012-05-10 20:40:51 -0400 | [diff] [blame] | 854 | } |
Ander Conselvan de Oliveira | d51624f | 2012-05-02 16:42:23 +0300 | [diff] [blame] | 855 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 856 | display.display = wl_display_connect(NULL); |
| 857 | assert(display.display); |
| 858 | |
Kristian Høgsberg | fa80e11 | 2012-10-10 21:34:26 -0400 | [diff] [blame] | 859 | display.registry = wl_display_get_registry(display.display); |
| 860 | wl_registry_add_listener(display.registry, |
| 861 | ®istry_listener, &display); |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 862 | |
Kristian Høgsberg | fa80e11 | 2012-10-10 21:34:26 -0400 | [diff] [blame] | 863 | wl_display_dispatch(display.display); |
Benjamin Franzke | 65e5051 | 2011-05-31 11:36:31 +0200 | [diff] [blame] | 864 | |
Kristian Høgsberg | 78fe753 | 2013-10-15 22:03:31 -0700 | [diff] [blame] | 865 | init_egl(&display, &window); |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 866 | create_surface(&window); |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 867 | init_gl(&window); |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 868 | |
Kristian Høgsberg | 191e0ee | 2012-10-29 17:41:46 -0400 | [diff] [blame] | 869 | display.cursor_surface = |
| 870 | wl_compositor_create_surface(display.compositor); |
| 871 | |
Pekka Paalanen | 88e60fc | 2011-12-13 12:09:09 +0200 | [diff] [blame] | 872 | sigint.sa_handler = signal_int; |
| 873 | sigemptyset(&sigint.sa_mask); |
| 874 | sigint.sa_flags = SA_RESETHAND; |
| 875 | sigaction(SIGINT, &sigint, NULL); |
| 876 | |
Kristian Høgsberg | 1e65840 | 2013-12-07 22:25:56 -0800 | [diff] [blame] | 877 | /* The mainloop here is a little subtle. Redrawing will cause |
| 878 | * EGL to read events so we can just call |
| 879 | * wl_display_dispatch_pending() to handle any events that got |
| 880 | * queued up as a side effect. */ |
| 881 | while (running && ret != -1) { |
| 882 | wl_display_dispatch_pending(display.display); |
Kristian Høgsberg | 1e65840 | 2013-12-07 22:25:56 -0800 | [diff] [blame] | 883 | redraw(&window, NULL, 0); |
| 884 | } |
Kristian Høgsberg | a495a5e | 2011-02-04 15:31:33 -0500 | [diff] [blame] | 885 | |
Pekka Paalanen | 88e60fc | 2011-12-13 12:09:09 +0200 | [diff] [blame] | 886 | fprintf(stderr, "simple-egl exiting\n"); |
| 887 | |
Pekka Paalanen | 2c2c106 | 2011-12-13 14:50:25 +0200 | [diff] [blame] | 888 | destroy_surface(&window); |
| 889 | fini_egl(&display); |
| 890 | |
Kristian Høgsberg | 191e0ee | 2012-10-29 17:41:46 -0400 | [diff] [blame] | 891 | wl_surface_destroy(display.cursor_surface); |
| 892 | if (display.cursor_theme) |
| 893 | wl_cursor_theme_destroy(display.cursor_theme); |
| 894 | |
Pekka Paalanen | 2c2c106 | 2011-12-13 14:50:25 +0200 | [diff] [blame] | 895 | if (display.shell) |
Kristian Høgsberg | dfaf65b | 2014-02-07 17:01:57 -0800 | [diff] [blame] | 896 | xdg_shell_destroy(display.shell); |
Pekka Paalanen | 2c2c106 | 2011-12-13 14:50:25 +0200 | [diff] [blame] | 897 | |
Nobuhiko Tanibata | 4f01a0b | 2014-11-27 13:24:42 +0900 | [diff] [blame] | 898 | if (display.ivi_application) |
| 899 | ivi_application_destroy(display.ivi_application); |
| 900 | |
Pekka Paalanen | 2c2c106 | 2011-12-13 14:50:25 +0200 | [diff] [blame] | 901 | if (display.compositor) |
| 902 | wl_compositor_destroy(display.compositor); |
| 903 | |
Pekka Paalanen | aac1c13 | 2012-12-04 16:01:15 +0200 | [diff] [blame] | 904 | wl_registry_destroy(display.registry); |
Pekka Paalanen | fb850c4 | 2011-12-15 10:07:52 +0200 | [diff] [blame] | 905 | wl_display_flush(display.display); |
Kristian Høgsberg | fcfc83f | 2012-02-28 14:29:19 -0500 | [diff] [blame] | 906 | wl_display_disconnect(display.display); |
Pekka Paalanen | 2c2c106 | 2011-12-13 14:50:25 +0200 | [diff] [blame] | 907 | |
Benjamin Franzke | aabdce0 | 2011-01-15 00:40:17 +0100 | [diff] [blame] | 908 | return 0; |
| 909 | } |