diff --git a/.gitignore b/.gitignore index 5d4a2eca..ce85118c 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,7 @@ CMakeFiles Makefile cmake_install.cmake install_manifest.txt +.clang_complete *.swp *.o *.a diff --git a/backend/CMakeLists.txt b/backend/CMakeLists.txt index 9594c318..37cee892 100644 --- a/backend/CMakeLists.txt +++ b/backend/CMakeLists.txt @@ -6,11 +6,10 @@ include_directories( ) add_library(wlr-backend - #wayland/backend.c - #wayland/registry.c - #wayland/wl_seat.c - #wayland/wl_output.c - + wayland/backend.c + wayland/registry.c + wayland/wl_seat.c + wayland/output.c drm/backend.c drm/drm.c diff --git a/backend/backend.c b/backend/backend.c index 02fd7479..30ced3e8 100644 --- a/backend/backend.c +++ b/backend/backend.c @@ -8,6 +8,7 @@ #include #include #include +#include #include #include "backend/libinput.h" #include "backend/udev.h" @@ -42,6 +43,9 @@ struct wlr_backend *wlr_backend_autocreate(struct wl_display *display, struct wlr_session *session) { // TODO: Choose the most appropriate backend for the situation // Attempt DRM+libinput + if (getenv("WAYLAND_DISPLAY") || getenv("_WAYLAND_DISPLAY")) { + return wlr_wl_backend_create(display, 1); + } struct wlr_udev *udev; if (!(udev = wlr_udev_create(display))) { wlr_log(L_ERROR, "Failed to start udev"); diff --git a/backend/drm/drm.c b/backend/drm/drm.c index befbfb94..5afdf3c3 100644 --- a/backend/drm/drm.c +++ b/backend/drm/drm.c @@ -260,6 +260,7 @@ static bool wlr_drm_output_set_mode(struct wlr_output_state *output, output->width = output->wlr_output->width = mode->width; output->height = output->wlr_output->height = mode->height; output->wlr_output->current_mode = mode; + wl_signal_emit(&output->wlr_output->events.resolution, output->wlr_output); if (!display_init_renderer(&state->renderer, output)) { wlr_log(L_ERROR, "Failed to initalise renderer for %s", output->wlr_output->name); diff --git a/backend/egl.c b/backend/egl.c index 2aac25b7..1ce2d8a7 100644 --- a/backend/egl.c +++ b/backend/egl.c @@ -6,7 +6,7 @@ #include "backend/egl.h" #include "common/log.h" -static const char *egl_error(void) { +const char *egl_error(void) { switch (eglGetError()) { case EGL_SUCCESS: return "Success"; @@ -68,11 +68,12 @@ static bool egl_exts() { return true; } -static bool egl_get_config(EGLDisplay disp, EGLConfig *out) { +static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLenum platform) { EGLint count = 0, matched = 0, ret; ret = eglGetConfigs(disp, NULL, 0, &count); if (ret == EGL_FALSE || count == 0) { + wlr_log(L_ERROR, "eglGetConfigs returned no configs"); return false; } @@ -80,12 +81,18 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out) { ret = eglChooseConfig(disp, NULL, configs, count, &matched); if (ret == EGL_FALSE) { + wlr_log(L_ERROR, "eglChooseConfig failed"); return false; } for (int i = 0; i < matched; ++i) { EGLint gbm_format; + if(platform == EGL_PLATFORM_WAYLAND_EXT) { + *out = configs[i]; + return true; + } + if (!eglGetConfigAttrib(disp, configs[i], EGL_NATIVE_VISUAL_ID, @@ -101,6 +108,7 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out) { } } + wlr_log(L_ERROR, "no valid egl config found"); return false; } @@ -109,7 +117,7 @@ bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *display) { if (!egl_exts()) { return false; } - + if (eglBindAPI(EGL_OPENGL_ES_API) == EGL_FALSE) { wlr_log(L_ERROR, "Failed to bind to the OpenGL ES API: %s", egl_error()); goto error; @@ -127,7 +135,7 @@ bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *display) { goto error; } - if (!egl_get_config(egl->display, &egl->config)) { + if (!egl_get_config(egl->display, &egl->config, platform)) { wlr_log(L_ERROR, "Failed to get EGL config"); goto error; } @@ -163,7 +171,7 @@ void wlr_egl_free(struct wlr_egl *egl) { eglDestroyContext(egl->display, egl->context); eglTerminate(egl->display); eglReleaseThread(); - eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); } EGLSurface wlr_egl_create_surface(struct wlr_egl *egl, void *window) { diff --git a/backend/wayland/backend.c b/backend/wayland/backend.c index 7f73c501..344cc35d 100644 --- a/backend/wayland/backend.c +++ b/backend/wayland/backend.c @@ -2,26 +2,28 @@ #include #include #include +#include +#include #include "backend/wayland.h" #include "common/log.h" +#include "types.h" +#include +#include -void wlr_wl_backend_free(struct wlr_wl_backend *backend) { - if (!backend) { - return; +static int dispatch_events(int fd, uint32_t mask, void *data) { + struct wlr_backend_state *state = data; + int count = 0; + if (mask & WL_EVENT_READABLE) { + count = wl_display_dispatch(state->remote_display); } - // TODO: Free surfaces - for (size_t i = 0; backend->outputs && i < backend->outputs->length; ++i) { - struct wlr_wl_output *output = backend->outputs->items[i]; - wlr_wl_output_free(output); - } - list_free(backend->outputs); - if (backend->seat) wlr_wl_seat_free(backend->seat); - if (backend->shm) wl_shm_destroy(backend->shm); - if (backend->shell) wl_shell_destroy(backend->shell); - if (backend->compositor) wl_compositor_destroy(backend->compositor); - if (backend->registry) wl_registry_destroy(backend->registry); - if (backend->remote_display) wl_display_disconnect(backend->remote_display); - free(backend); + if (mask & WL_EVENT_WRITABLE) { + count = wl_display_flush(state->remote_display); + } + if (mask == 0) { + count = wl_display_dispatch_pending(state->remote_display); + wl_display_flush(state->remote_display); + } + return count; } /* @@ -29,31 +31,116 @@ void wlr_wl_backend_free(struct wlr_wl_backend *backend) { * compositor and creates surfaces for each output, then registers globals on * the specified display. */ -struct wlr_wl_backend *wlr_wl_backend_init( - struct wl_display *display, size_t outputs) { - assert(display); - struct wlr_wl_backend *backend; - if (!(backend = calloc(sizeof(struct wlr_wl_backend), 1))) { - wlr_log(L_ERROR, "Could not allocate backend"); - goto error; +static bool wlr_wl_backend_init(struct wlr_backend_state* state) { + wlr_log(L_INFO, "Initializating wayland backend"); + + state->remote_display = wl_display_connect(getenv("_WAYLAND_DISPLAY")); + if (!state->remote_display) { + wlr_log_errno(L_ERROR, "Could not connect to remote display"); + return false; } - if (!(backend->outputs = list_create())) { - wlr_log(L_ERROR, "Could not allocate output list"); - goto error; + + if (!(state->registry = wl_display_get_registry(state->remote_display))) { + wlr_log_errno(L_ERROR, "Could not obtain reference to remote registry"); + return false; + } + + wlr_wl_registry_poll(state); + if (!(state->compositor) || (!(state->shell))) { + wlr_log_errno(L_ERROR, "Could not obtain retrieve required globals"); + return false; + } + + wlr_egl_init(&state->egl, EGL_PLATFORM_WAYLAND_EXT, state->remote_display); + for (size_t i = 0; i < state->num_outputs; ++i) { + if(!(state->outputs[i] = wlr_wl_output_create(state, i))) { + wlr_log_errno(L_ERROR, "Failed to create %zuth output", i); + return false; + } + } + + struct wl_event_loop *loop = wl_display_get_event_loop(state->local_display); + int fd = wl_display_get_fd(state->remote_display); + int events = WL_EVENT_READABLE | WL_EVENT_ERROR | + WL_EVENT_HANGUP | WL_EVENT_WRITABLE; + state->remote_display_src = wl_event_loop_add_fd(loop, fd, events, + dispatch_events, state); + wl_event_source_check(state->remote_display_src); + + return true; +} + +static void wlr_wl_backend_destroy(struct wlr_backend_state *state) { + if (!state) { + return; + } + + for (size_t i = 0; i < state->num_outputs; ++i) { + wlr_output_destroy(state->outputs[i]); } - backend->local_display = display; - backend->remote_display = wl_display_connect(getenv("_WAYLAND_DISPLAY")); - if (!backend->remote_display) { - wlr_log(L_ERROR, "Could not connect to remote display"); + + for (size_t i = 0; state->devices && i < state->devices->length; ++i) { + wlr_input_device_destroy(state->devices->items[i]); + } + + list_free(state->devices); + + wlr_egl_free(&state->egl); + free(state->outputs); + if (state->seat) wl_seat_destroy(state->seat); + if (state->shm) wl_shm_destroy(state->shm); + if (state->shell) wl_shell_destroy(state->shell); + if (state->compositor) wl_compositor_destroy(state->compositor); + if (state->registry) wl_registry_destroy(state->registry); + if (state->remote_display) wl_display_disconnect(state->remote_display); + free(state); +} + +static struct wlr_backend_impl backend_impl = { + .init = wlr_wl_backend_init, + .destroy = wlr_wl_backend_destroy +}; + + +struct wlr_backend *wlr_wl_backend_create(struct wl_display *display, + size_t num_outputs) { + wlr_log(L_INFO, "Creating wayland backend"); + + struct wlr_backend_state *state = calloc(1, sizeof(struct wlr_backend_state)); + if (!state) { + wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno)); + return NULL; + } + + struct wlr_backend *backend = wlr_backend_create(&backend_impl, state); + if (!backend) { + wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno)); + return NULL; + } + + if (!(state->devices = list_create())) { + wlr_log(L_ERROR, "Could not allocate devices list"); goto error; } - if (!(backend->registry = wl_display_get_registry(backend->remote_display))) { - wlr_log(L_ERROR, "Could not obtain reference to remote registry"); + + if (!(state->outputs = calloc(sizeof(void*), num_outputs))) { + wlr_log(L_ERROR, "Could not allocate outputs list"); goto error; } - wlr_wlb_registry_poll(backend); + + state->local_display = display; + state->backend = backend; + state->num_outputs = num_outputs; + return backend; + error: - wlr_wl_backend_free(backend); + if (state) { + free(state->outputs); + free(state->devices); + free(state->devices); + } + free(state); + free(backend); return NULL; } diff --git a/backend/wayland/output.c b/backend/wayland/output.c new file mode 100644 index 00000000..de4d2f4d --- /dev/null +++ b/backend/wayland/output.c @@ -0,0 +1,149 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include "types.h" +#include "backend/wayland.h" +#include "common/log.h" + +static struct wl_callback_listener frame_listener; + +static void surface_frame_callback(void *data, struct wl_callback *cb, uint32_t time) { + struct wlr_output_state *output = data; + assert(output); + + if (!eglMakeCurrent(output->backend->egl.display, + output->egl_surface, output->egl_surface, + output->backend->egl.context)) { + wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error()); + return; + } + + wl_signal_emit(&output->output->events.frame, output->output); + output->frame_callback = wl_surface_frame(output->surface); + wl_callback_add_listener(output->frame_callback, &frame_listener, output); + wl_callback_destroy(cb); + + if (!eglSwapBuffers(output->backend->egl.display, output->egl_surface)) { + wlr_log(L_ERROR, "eglSwapBuffers failed: %s", egl_error()); + return; + } +} + +static struct wl_callback_listener frame_listener = { + .done = surface_frame_callback +}; + +static void wlr_wl_output_transform(struct wlr_output_state *output, + enum wl_output_transform transform) { + // TODO +} + +static void wlr_wl_output_destroy(struct wlr_output_state *output) { + if(output->frame_callback) wl_callback_destroy(output->frame_callback); + eglDestroySurface(output->backend->egl.display, output->surface); + wl_egl_window_destroy(output->egl_window); + wl_shell_surface_destroy(output->shell_surface); + wl_surface_destroy(output->surface); + free(output); +} + +static struct wlr_output_impl output_impl = { + .transform = wlr_wl_output_transform, + .destroy = wlr_wl_output_destroy, +}; + +void handle_ping(void* data, struct wl_shell_surface* ssurface, uint32_t serial) { + struct wlr_output_state *output = data; + assert(output && output->shell_surface == ssurface); + wl_shell_surface_pong(ssurface, serial); +} + +void handle_configure(void *data, struct wl_shell_surface *wl_shell_surface, + uint32_t edges, int32_t width, int32_t height){ + struct wlr_output_state *ostate = data; + assert(ostate && ostate->shell_surface == wl_shell_surface); + struct wlr_output *output = ostate->output; + wl_egl_window_resize(ostate->egl_window, width, height, 0, 0); + output->width = width; + output->height = height; + wlr_output_update_matrix(output); + wl_signal_emit(&output->events.resolution, output); +} + +void handle_popup_done(void *data, struct wl_shell_surface *wl_shell_surface) { + wlr_log(L_ERROR, "Unexpected wl_shell_surface.popup_done event"); +} + +static struct wl_shell_surface_listener shell_surface_listener = { + .ping = handle_ping, + .configure = handle_configure, + .popup_done = handle_popup_done +}; + +struct wlr_output *wlr_wl_output_create(struct wlr_backend_state* backend, + size_t id) { + struct wlr_output_state *ostate; + if (!(ostate = calloc(sizeof(struct wlr_output_state), 1))) { + wlr_log(L_ERROR, "Failed to allocate wlr_output_state"); + return NULL; + } + + struct wlr_output *wlr_output = wlr_output_create(&output_impl, ostate); + if (!wlr_output) { + free(ostate); + wlr_log_errno(L_ERROR, "Allocation failed"); + return NULL; + } + + wlr_output->width = 640; + wlr_output->height = 480; + wlr_output->scale = 1; + strncpy(wlr_output->make, "wayland", sizeof(wlr_output->make)); + strncpy(wlr_output->model, "wayland", sizeof(wlr_output->model)); + snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%d", 1); + + ostate->id = id; + ostate->backend = backend; + ostate->output = wlr_output; + + // TODO: error handling + ostate->surface = wl_compositor_create_surface(backend->compositor); + ostate->shell_surface = wl_shell_get_shell_surface(backend->shell, ostate->surface); + + wl_shell_surface_set_class(ostate->shell_surface, "sway"); + wl_shell_surface_set_title(ostate->shell_surface, "sway-wl"); + wl_shell_surface_add_listener(ostate->shell_surface, &shell_surface_listener, ostate); + wl_shell_surface_set_toplevel(ostate->shell_surface); + + ostate->egl_window = wl_egl_window_create(ostate->surface, + wlr_output->width, wlr_output->height); + ostate->egl_surface = wlr_egl_create_surface(&backend->egl, ostate->egl_window); + + // start rendering loop per callbacks by rendering first frame + if (!eglMakeCurrent(ostate->backend->egl.display, + ostate->egl_surface, ostate->egl_surface, + ostate->backend->egl.context)) { + wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error()); + return false; + } + + glViewport(0, 0, wlr_output->width, wlr_output->height); + glClearColor(1.0, 1.0, 1.0, 1.0); + glClear(GL_COLOR_BUFFER_BIT); + + ostate->frame_callback = wl_surface_frame(ostate->surface); + wl_callback_add_listener(ostate->frame_callback, &frame_listener, ostate); + + if (!eglSwapBuffers(ostate->backend->egl.display, ostate->egl_surface)) { + wlr_log(L_ERROR, "eglSwapBuffers failed: %s", egl_error()); + return false; + } + + wl_signal_emit(&backend->backend->events.output_add, wlr_output); + return wlr_output; +} diff --git a/backend/wayland/registry.c b/backend/wayland/registry.c index 4a639f62..dfe3e37a 100644 --- a/backend/wayland/registry.c +++ b/backend/wayland/registry.c @@ -2,77 +2,29 @@ #include #include #include +#include +#include "types.h" #include "backend/wayland.h" #include "common/log.h" -static void registry_wl_seat(struct wlr_wl_backend *backend, - struct wl_seat *wl_seat, struct wl_registry *registry, uint32_t version) { - struct wlr_wl_seat *seat; - if (!(seat = calloc(sizeof(struct wlr_wl_seat), 1))) { - wlr_log(L_ERROR, "Failed to allocate wlr_wl_seat"); - goto error; - } - if (!(seat->keyboards = list_create())) { - wlr_log(L_ERROR, "Failed to allocate wlr_wl_seat"); - goto error; - } - if (!(seat->pointers = list_create())) { - wlr_log(L_ERROR, "Failed to allocate wlr_wl_pointer"); - goto error; - } - seat->wl_seat = wl_seat; - wl_seat_set_user_data(wl_seat, backend); - wl_seat_add_listener(wl_seat, &seat_listener, seat); - return; -error: - wlr_wl_seat_free(seat); - return; -} - -static void registry_wl_output(struct wlr_wl_backend *backend, - struct wl_output *wl_output, struct wl_registry *registry, uint32_t version) { - struct wlr_wl_output *output; - if (!(output = calloc(sizeof(struct wlr_wl_output), 1))) { - wlr_log(L_ERROR, "Failed to allocate wlr_wl_output"); - goto error; - } - if (!(output->modes = list_create())) { - wlr_log(L_ERROR, "Failed to allocate wlr_wl_output"); - goto error; - } - output->wl_output = wl_output; - output->scale = 1; - list_add(backend->outputs, output); - wl_output_set_user_data(wl_output, backend); - wl_output_add_listener(wl_output, &output_listener, output); - return; -error: - wlr_wl_output_free(output); - return; -} - static void registry_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) { - struct wlr_wl_backend *backend = data; + struct wlr_backend_state *state = data; wlr_log(L_DEBUG, "Remote wayland global: %s v%d", interface, version); if (strcmp(interface, wl_compositor_interface.name) == 0) { - backend->compositor = wl_registry_bind(registry, name, + state->compositor = wl_registry_bind(registry, name, &wl_compositor_interface, version); } else if (strcmp(interface, wl_shell_interface.name) == 0) { - backend->shell = wl_registry_bind(registry, name, + state->shell = wl_registry_bind(registry, name, &wl_shell_interface, version); } else if (strcmp(interface, wl_shm_interface.name) == 0) { - backend->shm = wl_registry_bind(registry, name, + state->shm = wl_registry_bind(registry, name, &wl_shm_interface, version); } else if (strcmp(interface, wl_seat_interface.name) == 0) { - struct wl_seat *wl_seat = wl_registry_bind(registry, name, + state->seat = wl_registry_bind(registry, name, &wl_seat_interface, version); - registry_wl_seat(backend, wl_seat, registry, version); - } else if (strcmp(interface, wl_output_interface.name) == 0) { - struct wl_output *wl_output = wl_registry_bind(registry, name, - &wl_output_interface, version); - registry_wl_output(backend, wl_output, registry, version); + wl_seat_add_listener(state->seat, &seat_listener, state); } } @@ -86,8 +38,8 @@ static const struct wl_registry_listener registry_listener = { .global_remove = registry_global_remove }; -void wlr_wlb_registry_poll(struct wlr_wl_backend *backend) { - wl_registry_add_listener(backend->registry, ®istry_listener, backend); - wl_display_dispatch(backend->remote_display); - wl_display_roundtrip(backend->remote_display); +void wlr_wl_registry_poll(struct wlr_backend_state *state) { + wl_registry_add_listener(state->registry, ®istry_listener, state); + wl_display_dispatch(state->remote_display); + wl_display_roundtrip(state->remote_display); } diff --git a/backend/wayland/wl_output.c b/backend/wayland/wl_output.c deleted file mode 100644 index cc4e9cce..00000000 --- a/backend/wayland/wl_output.c +++ /dev/null @@ -1,64 +0,0 @@ -#define _XOPEN_SOURCE 500 -#include -#include -#include -#include -#include -#include "backend/wayland.h" -#include "common/log.h" - -static void wl_output_handle_mode(void *data, struct wl_output *wl_output, - uint32_t flags, int32_t width, int32_t height, int32_t refresh) { - struct wlr_wl_output *output = data; - assert(output->wl_output == wl_output); - struct wlr_wl_output_mode *mode; - if (!(mode = calloc(sizeof(struct wlr_wl_output_mode), 1))) { - wlr_log(L_ERROR, "Failed to allocate wlr_wl_output_mode"); - return; - } - mode->flags = flags; - mode->width = width; - mode->height = height; - mode->refresh = refresh; - list_add(output->modes, mode); - wlr_log(L_DEBUG, "Got mode for output %p: %dx%d @ %.2fHz%s%s", - wl_output, width, height, refresh / 1000.0, - (flags & WL_OUTPUT_MODE_PREFERRED) ? " (preferred)" : "", - (flags & WL_OUTPUT_MODE_CURRENT) ? " (current)" : ""); -} - -static void wl_output_handle_geometry(void *data, struct wl_output *wl_output, - int32_t x, int32_t y, int32_t physical_width, int32_t physical_height, - int32_t subpixel, const char *make, const char *model, int32_t transform) { - struct wlr_wl_output *output = data; - assert(output->wl_output == wl_output); - output->x = x; - output->y = y; - output->phys_width = physical_width; - output->phys_height = physical_height; - output->subpixel = subpixel; - output->make = strdup(make); - output->model = strdup(model); - output->transform = transform; - wlr_log(L_DEBUG, "Got info for output %p %dx%d (%dmm x %dmm) %s %s", - wl_output, (int)x, (int)y, (int)physical_width, (int)physical_height, - make, model); -} - -static void wl_output_handle_scale(void *data, struct wl_output *wl_output, int32_t factor) { - struct wlr_wl_output *output = data; - assert(output->wl_output == wl_output); - output->scale = factor; - wlr_log(L_DEBUG, "Got scale factor for output %p: %d", wl_output, factor); -} - -static void wl_output_handle_done(void *data, struct wl_output *wl_output) { - // TODO: notify of changes? Probably not necessary for this backend -} - -const struct wl_output_listener output_listener = { - .mode = wl_output_handle_mode, - .geometry = wl_output_handle_geometry, - .scale = wl_output_handle_scale, - .done = wl_output_handle_done -}; diff --git a/backend/wayland/wl_seat.c b/backend/wayland/wl_seat.c index bc2b21a8..240cbbb0 100644 --- a/backend/wayland/wl_seat.c +++ b/backend/wayland/wl_seat.c @@ -4,49 +4,89 @@ #include #include #include +#include +#include "types.h" #include "backend/wayland.h" #include "common/log.h" +static void wlr_wl_device_destroy(struct wlr_input_device_state *state) { + free(state); +} + +static struct wlr_input_device_impl input_device_impl = { + .destroy = wlr_wl_device_destroy +}; + +static struct wlr_input_device *allocate_device(struct wlr_backend_state *state, + enum wlr_input_device_type type) { + struct wlr_input_device_state *devstate = + calloc(1, sizeof(struct wlr_input_device_state)); + if(!devstate) { + wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno)); + return NULL; + } + + // TODO: any way to retrieve those information? + int vendor = 0; + int product = 0; + const char *name = "unknown;wayland"; + struct wlr_input_device *wlr_device = wlr_input_device_create( + type, &input_device_impl, devstate, + name, vendor, product); + if(!wlr_device) { + free(devstate); + return NULL; + } + + list_add(state->devices, wlr_device); + return wlr_device; +} + static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat, enum wl_seat_capability caps) { - struct wlr_wl_seat *seat = data; - assert(seat->wl_seat == wl_seat); - struct wlr_wl_backend *backend = wl_seat_get_user_data(wl_seat); - assert(backend); + struct wlr_backend_state *state = data; + assert(state->seat == wl_seat); + // TODO: add listeners and receive input if ((caps & WL_SEAT_CAPABILITY_POINTER)) { wlr_log(L_DEBUG, "seat %p offered pointer", wl_seat); struct wl_pointer *wl_pointer = wl_seat_get_pointer(wl_seat); - struct wlr_wl_pointer *pointer; - if (!(pointer = calloc(sizeof(struct wlr_wl_pointer), 1))) { + + struct wlr_input_device *wlr_device = allocate_device(state, + WLR_INPUT_DEVICE_POINTER); + if(!wlr_device) { wl_pointer_destroy(wl_pointer); - wlr_log(L_ERROR, "Unable to allocate wlr_wl_pointer"); + wlr_log(L_ERROR, "Unable to allocate wl_pointer device"); return; } - pointer->wl_pointer = wl_pointer; - //wl_pointer_add_listener(wl_pointer, &pointer_listener, backend->registry); TODO - } + wlr_device->pointer = wlr_pointer_create(NULL, NULL); + list_add(state->devices, wlr_device); + wl_signal_emit(&state->backend->events.input_add, wlr_device); + } if ((caps & WL_SEAT_CAPABILITY_KEYBOARD)) { wlr_log(L_DEBUG, "seat %p offered keyboard", wl_seat); struct wl_keyboard *wl_keyboard = wl_seat_get_keyboard(wl_seat); - struct wlr_wl_keyboard *keyboard; - if (!(keyboard = calloc(sizeof(struct wlr_wl_pointer), 1))) { - wl_keyboard_destroy(wl_keyboard); - wlr_log(L_ERROR, "Unable to allocate wlr_wl_keyboard"); + struct wlr_input_device *wlr_device = allocate_device(state, + WLR_INPUT_DEVICE_KEYBOARD); + if(!wlr_device) { + wl_keyboard_release(wl_keyboard); + wlr_log(L_ERROR, "Unable to allocate wl_pointer device"); return; } - keyboard->wl_keyboard = wl_keyboard; - //wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, backend->registry); TODO + + wlr_device->keyboard = wlr_keyboard_create(NULL, NULL); + list_add(state->devices, wlr_device); + wl_signal_emit(&state->backend->events.input_add, wlr_device); } // TODO: touch } static void seat_handle_name(void *data, struct wl_seat *wl_seat, const char *name) { - struct wlr_wl_seat *seat = data; - assert(seat->wl_seat == wl_seat); - seat->name = strdup(name); + struct wlr_backend_state *state = data; + assert(state->seat == wl_seat); + state->seatName = strdup(name); } const struct wl_seat_listener seat_listener = { diff --git a/example/pointer.c b/example/pointer.c index ddb665a1..8735c61e 100644 --- a/example/pointer.c +++ b/example/pointer.c @@ -110,22 +110,21 @@ int main(int argc, char *argv[]) { .default_color = { 0.25f, 0.25f, 0.25f, 1 }, .clear_color = { 0.25f, 0.25f, 0.25f, 1 } }; - struct compositor_state compositor; - - compositor_init(&compositor); + struct compositor_state compositor = { 0 }; + compositor.data = &state; compositor.output_add_cb = handle_output_add; compositor.output_frame_cb = handle_output_frame; compositor.keyboard_key_cb = handle_keyboard_key; compositor.pointer_motion_cb = handle_pointer_motion; compositor.pointer_button_cb = handle_pointer_button; compositor.pointer_axis_cb = handle_pointer_axis; + compositor_init(&compositor); state.renderer = wlr_gles3_renderer_init(); state.cat_texture = wlr_render_surface_init(state.renderer); wlr_surface_attach_pixels(state.cat_texture, GL_RGBA, cat_tex.width, cat_tex.height, cat_tex.pixel_data); - compositor.data = &state; compositor_run(&compositor); wlr_surface_destroy(state.cat_texture); diff --git a/example/rotation.c b/example/rotation.c index f4b7625e..d7b6b169 100644 --- a/example/rotation.c +++ b/example/rotation.c @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -193,22 +194,22 @@ static void parse_args(int argc, char *argv[], struct wl_list *config) { int main(int argc, char *argv[]) { struct sample_state state = { 0 }; - struct compositor_state compositor; wl_list_init(&state.config); parse_args(argc, argv, &state.config); - compositor_init(&compositor); + struct compositor_state compositor = { 0 }; + compositor.data = &state; compositor.output_add_cb = handle_output_add; compositor.output_remove_cb = handle_output_remove; compositor.output_frame_cb = handle_output_frame; compositor.keyboard_key_cb = handle_keyboard_key; + compositor_init(&compositor); state.renderer = wlr_gles3_renderer_init(); state.cat_texture = wlr_render_surface_init(state.renderer); wlr_surface_attach_pixels(state.cat_texture, GL_RGBA, cat_tex.width, cat_tex.height, cat_tex.pixel_data); - compositor.data = &state; compositor_run(&compositor); wlr_surface_destroy(state.cat_texture); diff --git a/example/shared.c b/example/shared.c index be1bdee7..6af3042b 100644 --- a/example/shared.c +++ b/example/shared.c @@ -383,7 +383,9 @@ static void output_add_notify(struct wl_listener *listener, void *data) { fprintf(stderr, "Output '%s' added\n", output->name); fprintf(stderr, "%s %s %"PRId32"mm x %"PRId32"mm\n", output->make, output->model, output->phys_width, output->phys_height); - wlr_output_set_mode(output, output->modes->items[0]); + if (output->modes->length > 0) { + wlr_output_set_mode(output, output->modes->items[0]); + } struct output_state *ostate = calloc(1, sizeof(struct output_state)); clock_gettime(CLOCK_MONOTONIC, &ostate->last_frame); ostate->output = output; @@ -418,8 +420,6 @@ static void output_remove_notify(struct wl_listener *listener, void *data) { } void compositor_init(struct compositor_state *state) { - memset(state, 0, sizeof(struct compositor_state)); - state->display = wl_display_create(); state->event_loop = wl_display_get_event_loop(state->display); state->session = wlr_session_start(state->display); @@ -457,14 +457,14 @@ void compositor_init(struct compositor_state *state) { state->backend = wlr; clock_gettime(CLOCK_MONOTONIC, &state->last_frame); -} -void compositor_run(struct compositor_state *state) { if (!wlr_backend_init(state->backend)) { fprintf(stderr, "Failed to initialize backend\n"); exit(1); } +} +void compositor_run(struct compositor_state *state) { while (!state->exit) { wl_event_loop_dispatch(state->event_loop, 0); } diff --git a/example/simple.c b/example/simple.c index 5a5a1300..f3a66db9 100644 --- a/example/simple.c +++ b/example/simple.c @@ -50,11 +50,11 @@ int main() { .color = { 1.0, 0.0, 0.0 }, .dec = 0, }; - struct compositor_state compositor; - + struct compositor_state compositor = { 0, + .data = &state, + .output_frame_cb = handle_output_frame, + .keyboard_key_cb = handle_keyboard_key, + }; compositor_init(&compositor); - compositor.output_frame_cb = handle_output_frame; - compositor.keyboard_key_cb = handle_keyboard_key; - compositor.data = &state; compositor_run(&compositor); } diff --git a/example/tablet.c b/example/tablet.c index 3c5b583e..6be006f0 100644 --- a/example/tablet.c +++ b/example/tablet.c @@ -145,19 +145,19 @@ int main(int argc, char *argv[]) { .tool_color = { 1, 1, 1, 1 }, .pad_color = { 0.75, 0.75, 0.75, 1.0 } }; - struct compositor_state compositor; - + struct compositor_state compositor = { 0, + .data = &state, + .output_frame_cb = handle_output_frame, + .keyboard_key_cb = handle_keyboard_key, + .tool_axis_cb = handle_tool_axis, + .tool_proximity_cb = handle_tool_proximity, + .tool_button_cb = handle_tool_button, + .pad_button_cb = handle_pad_button, + }; compositor_init(&compositor); - compositor.output_frame_cb = handle_output_frame; - compositor.keyboard_key_cb = handle_keyboard_key; - compositor.tool_axis_cb = handle_tool_axis; - compositor.tool_proximity_cb = handle_tool_proximity; - compositor.tool_button_cb = handle_tool_button; - compositor.pad_button_cb = handle_pad_button; state.renderer = wlr_gles3_renderer_init(); - compositor.data = &state; compositor_run(&compositor); wlr_renderer_destroy(state.renderer); diff --git a/example/touch.c b/example/touch.c index 46eddf62..1b4233bb 100644 --- a/example/touch.c +++ b/example/touch.c @@ -100,21 +100,21 @@ int main(int argc, char *argv[]) { struct sample_state state = { .touch_points = list_create() }; - struct compositor_state compositor; - + struct compositor_state compositor = { 0, + .data = &state, + .output_frame_cb = handle_output_frame, + .keyboard_key_cb = handle_keyboard_key, + .touch_down_cb = handle_touch_down, + .touch_up_cb = handle_touch_up, + .touch_motion_cb = handle_touch_motion, + }; compositor_init(&compositor); - compositor.output_frame_cb = handle_output_frame; - compositor.keyboard_key_cb = handle_keyboard_key; - compositor.touch_down_cb = handle_touch_down; - compositor.touch_up_cb = handle_touch_up; - compositor.touch_motion_cb = handle_touch_motion; state.renderer = wlr_gles3_renderer_init(); state.cat_texture = wlr_render_surface_init(state.renderer); wlr_surface_attach_pixels(state.cat_texture, GL_RGBA, cat_tex.width, cat_tex.height, cat_tex.pixel_data); - compositor.data = &state; compositor_run(&compositor); wlr_surface_destroy(state.cat_texture); diff --git a/include/backend/egl.h b/include/backend/egl.h index 8cef36b7..0422a52b 100644 --- a/include/backend/egl.h +++ b/include/backend/egl.h @@ -10,6 +10,7 @@ struct wlr_egl { EGLContext context; }; +const char *egl_error(void); bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *display); void wlr_egl_free(struct wlr_egl *egl); EGLSurface wlr_egl_create_surface(struct wlr_egl *egl, void *window); diff --git a/include/backend/wayland.h b/include/backend/wayland.h index 94aa0962..03667c9a 100644 --- a/include/backend/wayland.h +++ b/include/backend/wayland.h @@ -3,10 +3,12 @@ #include #include +#include #include -#include +#include +#include "backend/egl.h" -struct wlr_wl_backend { +struct wlr_backend_state { /* local state */ struct wl_display *local_display; /* remote state */ @@ -15,13 +17,39 @@ struct wlr_wl_backend { struct wl_compositor *compositor; struct wl_shell *shell; struct wl_shm *shm; - struct wlr_wl_seat *seat; - list_t *outputs; + struct wl_seat *seat; + const char *seatName; + + struct wlr_backend *backend; + list_t *devices; + + struct wl_event_source* remote_display_src; + + size_t num_outputs; + struct wlr_output **outputs; + struct wlr_egl egl; +}; + +struct wlr_output_state { + size_t id; + struct wlr_backend_state *backend; + struct wlr_output *output; + struct wl_surface *surface; + struct wl_shell_surface *shell_surface; + struct wl_egl_window* egl_window; + struct wl_callback* frame_callback; + void* egl_surface; +}; + +struct wlr_input_device_state { + enum wlr_input_device_type type; + void *resource; }; -void wlr_wlb_registry_poll(struct wlr_wl_backend *backend); +void wlr_wl_registry_poll(struct wlr_backend_state *backend); +struct wlr_output *wlr_wl_output_create(struct wlr_backend_state* backend, + size_t id); extern const struct wl_seat_listener seat_listener; -extern const struct wl_output_listener output_listener; #endif diff --git a/include/types.h b/include/types.h index 54aa5606..f53cac02 100644 --- a/include/types.h +++ b/include/types.h @@ -20,6 +20,7 @@ struct wlr_output_impl { struct wlr_output *wlr_output_create(struct wlr_output_impl *impl, struct wlr_output_state *state); void wlr_output_free(struct wlr_output *output); +void wlr_output_update_matrix(struct wlr_output *output); struct wlr_keyboard_impl { void (*destroy)(struct wlr_keyboard_state *state); diff --git a/include/wlr/backend/wayland.h b/include/wlr/backend/wayland.h index 4318cc26..83b465c1 100644 --- a/include/wlr/backend/wayland.h +++ b/include/wlr/backend/wayland.h @@ -1,14 +1,11 @@ -#ifndef _WLR_BACKEND_WAYLAND_INTERNAL_H -#define _WLR_BACKEND_WAYLAND_INTERNAL_H +#ifndef WLR_BACKEND_WAYLAND_H +#define WLR_BACKEND_WAYLAND_H #include #include -#include +#include -struct wlr_wl_backend; - -void wlr_wl_backend_free(struct wlr_wl_backend *backend); -struct wlr_wl_backend *wlr_wl_backend_init(struct wl_display *display, +struct wlr_backend *wlr_wl_backend_create(struct wl_display *display, size_t outputs); #endif diff --git a/include/wlr/types.h b/include/wlr/types.h index 1d2abab5..6b6a3389 100644 --- a/include/wlr/types.h +++ b/include/wlr/types.h @@ -33,11 +33,13 @@ struct wlr_output { float transform_matrix[16]; + /* Note: some backends may have zero modes */ list_t *modes; struct wlr_output_mode *current_mode; struct { struct wl_signal frame; + struct wl_signal resolution; } events; }; diff --git a/render/gles3/renderer.c b/render/gles3/renderer.c index b0056193..d029c0fb 100644 --- a/render/gles3/renderer.c +++ b/render/gles3/renderer.c @@ -71,6 +71,7 @@ static void init_default_shaders() { if (!compile_program(quad_vertex_src, ellipse_fragment_src, &shaders.ellipse)) { goto error; } + wlr_log(L_DEBUG, "Compiled default shaders"); return; error: wlr_log(L_ERROR, "Failed to set up default shaders!"); @@ -141,8 +142,10 @@ static bool wlr_gles3_render_surface(struct wlr_renderer_state *state, GL_CALL(glUseProgram(shaders.rgba)); break; default: + wlr_log(L_ERROR, "No shader for this surface format"); return false; } + gles3_flush_errors(); GL_CALL(glBindVertexArray(vao)); GL_CALL(glBindBuffer(GL_ARRAY_BUFFER, vbo)); GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo)); diff --git a/types/wlr_output.c b/types/wlr_output.c index 8c21f706..28996fa7 100644 --- a/types/wlr_output.c +++ b/types/wlr_output.c @@ -65,6 +65,10 @@ static void set_matrix(float mat[static 16], int32_t width, int32_t height, mat[15] = 1.0f; } +void wlr_output_update_matrix(struct wlr_output *output) { + set_matrix(output->transform_matrix, output->width, output->height, output->transform); +} + struct wlr_output *wlr_output_create(struct wlr_output_impl *impl, struct wlr_output_state *state) { struct wlr_output *output = calloc(1, sizeof(struct wlr_output)); @@ -73,6 +77,7 @@ struct wlr_output *wlr_output_create(struct wlr_output_impl *impl, output->modes = list_create(); output->transform = WL_OUTPUT_TRANSFORM_NORMAL; wl_signal_init(&output->events.frame); + wl_signal_init(&output->events.resolution); return output; } @@ -81,22 +86,31 @@ void wlr_output_enable(struct wlr_output *output, bool enable) { } bool wlr_output_set_mode(struct wlr_output *output, struct wlr_output_mode *mode) { - set_matrix(output->transform_matrix, mode->width, mode->height, output->transform); + if (!output->impl || !output->impl->set_mode) { + return false; + } + wlr_output_update_matrix(output); return output->impl->set_mode(output->state, mode); } void wlr_output_transform(struct wlr_output *output, enum wl_output_transform transform) { - set_matrix(output->transform_matrix, output->width, output->height, transform); + wlr_output_update_matrix(output); output->impl->transform(output->state, transform); } bool wlr_output_set_cursor(struct wlr_output *output, const uint8_t *buf, int32_t stride, uint32_t width, uint32_t height) { + if (!output->impl || !output->impl->set_cursor) { + return false; + } return output->impl->set_cursor(output->state, buf, stride, width, height); } bool wlr_output_move_cursor(struct wlr_output *output, int x, int y) { + if (!output->impl || !output->impl->move_cursor) { + return false; + } return output->impl->move_cursor(output->state, x, y); }