| /* |
| * Copyright © 2011 Benjamin Franzke |
| * |
| * Permission to use, copy, modify, distribute, and sell this software and its |
| * documentation for any purpose is hereby granted without fee, provided that |
| * the above copyright notice appear in all copies and that both that copyright |
| * notice and this permission notice appear in supporting documentation, and |
| * that the name of the copyright holders not be used in advertising or |
| * publicity pertaining to distribution of the software without specific, |
| * written prior permission. The copyright holders make no representations |
| * about the suitability of this software for any purpose. It is provided "as |
| * is" without express or implied warranty. |
| * |
| * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, |
| * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO |
| * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR |
| * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, |
| * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE |
| * OF THIS SOFTWARE. |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <stdbool.h> |
| #include <math.h> |
| #include <assert.h> |
| |
| #include <wayland-client.h> |
| #include <wayland-egl.h> |
| |
| #include <GLES2/gl2.h> |
| #include <EGL/egl.h> |
| |
| struct display { |
| struct wl_display *display; |
| struct wl_compositor *compositor; |
| struct wl_shell *shell; |
| struct { |
| EGLDisplay dpy; |
| EGLContext ctx; |
| EGLConfig conf; |
| } egl; |
| uint32_t mask; |
| }; |
| |
| struct window { |
| struct display *display; |
| struct { |
| int width, height; |
| } geometry; |
| struct { |
| GLuint fbo; |
| GLuint color_rbo; |
| |
| GLuint program; |
| GLuint rotation_uniform; |
| |
| GLuint pos; |
| GLuint col; |
| } gl; |
| |
| struct wl_egl_window *native; |
| struct wl_surface *surface; |
| EGLSurface egl_surface; |
| }; |
| |
| static const char *vert_shader_text = |
| "uniform mat4 rotation;\n" |
| "attribute vec4 pos;\n" |
| "attribute vec4 color;\n" |
| "varying vec4 v_color;\n" |
| "void main() {\n" |
| " gl_Position = rotation * pos;\n" |
| " v_color = color;\n" |
| "}\n"; |
| |
| static const char *frag_shader_text = |
| "precision mediump float;\n" |
| "varying vec4 v_color;\n" |
| "void main() {\n" |
| " gl_FragColor = v_color;\n" |
| "}\n"; |
| |
| static void |
| init_egl(struct display *display) |
| { |
| static const EGLint context_attribs[] = { |
| EGL_CONTEXT_CLIENT_VERSION, 2, |
| EGL_NONE |
| }; |
| |
| static const EGLint config_attribs[] = { |
| EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_VG_ALPHA_FORMAT_PRE_BIT, |
| EGL_RED_SIZE, 1, |
| EGL_GREEN_SIZE, 1, |
| EGL_BLUE_SIZE, 1, |
| EGL_ALPHA_SIZE, 1, |
| EGL_DEPTH_SIZE, 1, |
| EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, |
| EGL_NONE |
| }; |
| |
| EGLint major, minor, n; |
| EGLBoolean ret; |
| |
| display->egl.dpy = eglGetDisplay(display->display); |
| assert(display->egl.dpy); |
| |
| ret = eglInitialize(display->egl.dpy, &major, &minor); |
| assert(ret == EGL_TRUE); |
| ret = eglBindAPI(EGL_OPENGL_ES_API); |
| assert(ret == EGL_TRUE); |
| |
| assert(eglChooseConfig(display->egl.dpy, config_attribs, |
| &display->egl.conf, 1, &n) && n == 1); |
| |
| display->egl.ctx = eglCreateContext(display->egl.dpy, |
| display->egl.conf, |
| EGL_NO_CONTEXT, context_attribs); |
| assert(display->egl.ctx); |
| |
| } |
| |
| static GLuint |
| create_shader(struct window *window, const char *source, GLenum shader_type) |
| { |
| GLuint shader; |
| GLint status; |
| |
| shader = glCreateShader(shader_type); |
| assert(shader != 0); |
| |
| glShaderSource(shader, 1, (const char **) &source, NULL); |
| glCompileShader(shader); |
| |
| glGetShaderiv(shader, GL_COMPILE_STATUS, &status); |
| if (!status) { |
| char log[1000]; |
| GLsizei len; |
| glGetShaderInfoLog(shader, 1000, &len, log); |
| fprintf(stderr, "Error: compiling %s: %*s\n", |
| shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment", |
| len, log); |
| exit(1); |
| } |
| |
| return shader; |
| } |
| |
| static void |
| init_gl(struct window *window) |
| { |
| GLuint frag, vert; |
| GLint status; |
| |
| glViewport(0, 0, window->geometry.width, window->geometry.height); |
| |
| frag = create_shader(window, frag_shader_text, GL_FRAGMENT_SHADER); |
| vert = create_shader(window, vert_shader_text, GL_VERTEX_SHADER); |
| |
| window->gl.program = glCreateProgram(); |
| glAttachShader(window->gl.program, frag); |
| glAttachShader(window->gl.program, vert); |
| glLinkProgram(window->gl.program); |
| |
| glGetProgramiv(window->gl.program, GL_LINK_STATUS, &status); |
| if (!status) { |
| char log[1000]; |
| GLsizei len; |
| glGetProgramInfoLog(window->gl.program, 1000, &len, log); |
| fprintf(stderr, "Error: linking:\n%*s\n", len, log); |
| exit(1); |
| } |
| |
| glUseProgram(window->gl.program); |
| |
| window->gl.pos = 0; |
| window->gl.pos = 1; |
| |
| glBindAttribLocation(window->gl.program, window->gl.pos, "pos"); |
| glBindAttribLocation(window->gl.program, window->gl.col, "color"); |
| glLinkProgram(window->gl.program); |
| |
| window->gl.rotation_uniform = |
| glGetUniformLocation(window->gl.program, "rotation"); |
| } |
| |
| static void |
| create_surface(struct window *window) |
| { |
| struct display *display = window->display; |
| EGLBoolean ret; |
| static const EGLint surface_attribs[] = { |
| EGL_ALPHA_FORMAT, EGL_ALPHA_FORMAT_PRE, |
| EGL_NONE |
| }; |
| |
| window->surface = wl_compositor_create_surface(display->compositor); |
| window->native = |
| wl_egl_window_create(window->surface, |
| window->geometry.width, |
| window->geometry.height); |
| window->egl_surface = |
| eglCreateWindowSurface(display->egl.dpy, |
| display->egl.conf, |
| window->native, |
| surface_attribs); |
| |
| wl_shell_set_toplevel(display->shell, window->surface); |
| |
| ret = eglMakeCurrent(window->display->egl.dpy, window->egl_surface, |
| window->egl_surface, window->display->egl.ctx); |
| assert(ret == EGL_TRUE); |
| } |
| |
| static const struct wl_callback_listener frame_listener; |
| |
| static void |
| redraw(void *data, struct wl_callback *callback, uint32_t time) |
| { |
| struct window *window = data; |
| static const GLfloat verts[3][2] = { |
| { -0.5, -0.5 }, |
| { 0.5, -0.5 }, |
| { 0, 0.5 } |
| }; |
| static const GLfloat colors[3][3] = { |
| { 1, 0, 0 }, |
| { 0, 1, 0 }, |
| { 0, 0, 1 } |
| }; |
| GLfloat angle; |
| GLfloat rotation[4][4] = { |
| { 1, 0, 0, 0 }, |
| { 0, 1, 0, 0 }, |
| { 0, 0, 1, 0 }, |
| { 0, 0, 0, 1 } |
| }; |
| static const int32_t speed_div = 5; |
| static uint32_t start_time = 0; |
| |
| if (start_time == 0) |
| start_time = time; |
| |
| angle = ((time-start_time) / speed_div) % 360 * M_PI / 180.0; |
| rotation[0][0] = cos(angle); |
| rotation[0][2] = sin(angle); |
| rotation[2][0] = -sin(angle); |
| rotation[2][2] = cos(angle); |
| |
| glUniformMatrix4fv(window->gl.rotation_uniform, 1, GL_FALSE, |
| (GLfloat *) rotation); |
| |
| glClearColor(0.0, 0.0, 0.0, 0.5); |
| glClear(GL_COLOR_BUFFER_BIT); |
| |
| glVertexAttribPointer(window->gl.pos, 2, GL_FLOAT, GL_FALSE, 0, verts); |
| glVertexAttribPointer(window->gl.col, 3, GL_FLOAT, GL_FALSE, 0, colors); |
| glEnableVertexAttribArray(window->gl.pos); |
| glEnableVertexAttribArray(window->gl.col); |
| |
| glDrawArrays(GL_TRIANGLES, 0, 3); |
| |
| glDisableVertexAttribArray(window->gl.pos); |
| glDisableVertexAttribArray(window->gl.col); |
| |
| glFlush(); |
| |
| eglSwapBuffers(window->display->egl.dpy, window->egl_surface); |
| if (callback) |
| wl_callback_destroy(callback); |
| |
| callback = wl_surface_frame(window->surface); |
| wl_callback_add_listener(callback, &frame_listener, window); |
| } |
| |
| static const struct wl_callback_listener frame_listener = { |
| redraw |
| }; |
| |
| static void |
| display_handle_global(struct wl_display *display, uint32_t id, |
| const char *interface, uint32_t version, void *data) |
| { |
| struct display *d = data; |
| |
| if (strcmp(interface, "wl_compositor") == 0) { |
| d->compositor = |
| wl_display_bind(display, id, &wl_compositor_interface); |
| } else if (strcmp(interface, "wl_shell") == 0) { |
| d->shell = wl_display_bind(display, id, &wl_shell_interface); |
| } |
| } |
| |
| static int |
| event_mask_update(uint32_t mask, void *data) |
| { |
| struct display *d = data; |
| |
| d->mask = mask; |
| |
| return 0; |
| } |
| |
| int |
| main(int argc, char **argv) |
| { |
| struct display display = { 0 }; |
| struct window window = { 0 }; |
| |
| memset(&display, 0, sizeof display); |
| memset(&window, 0, sizeof window); |
| |
| window.display = &display; |
| window.geometry.width = 250; |
| window.geometry.height = 250; |
| |
| display.display = wl_display_connect(NULL); |
| assert(display.display); |
| |
| wl_display_add_global_listener(display.display, |
| display_handle_global, &display); |
| |
| wl_display_get_fd(display.display, event_mask_update, &display); |
| wl_display_iterate(display.display, WL_DISPLAY_READABLE); |
| |
| init_egl(&display); |
| create_surface(&window); |
| init_gl(&window); |
| |
| redraw(&window, NULL, 0); |
| |
| while (true) |
| wl_display_iterate(display.display, display.mask); |
| |
| return 0; |
| } |