mirror of
https://github.com/hyprwm/wlroots-hyprland.git
synced 2024-11-04 20:55:58 +01:00
Merge pull request #17 from nyorain/wayland-backend
Basic Wayland backend
This commit is contained in:
commit
33f2c66fca
23 changed files with 460 additions and 237 deletions
1
.gitignore
vendored
1
.gitignore
vendored
|
@ -3,6 +3,7 @@ CMakeFiles
|
|||
Makefile
|
||||
cmake_install.cmake
|
||||
install_manifest.txt
|
||||
.clang_complete
|
||||
*.swp
|
||||
*.o
|
||||
*.a
|
||||
|
|
|
@ -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
|
||||
|
||||
|
|
|
@ -8,6 +8,7 @@
|
|||
#include <wlr/backend/interface.h>
|
||||
#include <wlr/backend/drm.h>
|
||||
#include <wlr/backend/libinput.h>
|
||||
#include <wlr/backend/wayland.h>
|
||||
#include <wlr/backend/multi.h>
|
||||
#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");
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -2,26 +2,28 @@
|
|||
#include <stdint.h>
|
||||
#include <wayland-server.h>
|
||||
#include <assert.h>
|
||||
#include <wlr/backend/interface.h>
|
||||
#include <wlr/types.h>
|
||||
#include "backend/wayland.h"
|
||||
#include "common/log.h"
|
||||
#include "types.h"
|
||||
#include <EGL/egl.h>
|
||||
#include <EGL/eglext.h>
|
||||
|
||||
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);
|
||||
if (mask & WL_EVENT_WRITABLE) {
|
||||
count = wl_display_flush(state->remote_display);
|
||||
}
|
||||
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 == 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");
|
||||
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 (!(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]);
|
||||
}
|
||||
|
||||
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->outputs = list_create())) {
|
||||
wlr_log(L_ERROR, "Could not allocate output list");
|
||||
|
||||
if (!(state->outputs = calloc(sizeof(void*), num_outputs))) {
|
||||
wlr_log(L_ERROR, "Could not allocate outputs list");
|
||||
goto error;
|
||||
}
|
||||
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");
|
||||
goto error;
|
||||
}
|
||||
if (!(backend->registry = wl_display_get_registry(backend->remote_display))) {
|
||||
wlr_log(L_ERROR, "Could not obtain reference to remote registry");
|
||||
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;
|
||||
}
|
||||
|
|
149
backend/wayland/output.c
Normal file
149
backend/wayland/output.c
Normal file
|
@ -0,0 +1,149 @@
|
|||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <wayland-client.h>
|
||||
#include <wlr/types.h>
|
||||
#include <GLES3/gl3.h>
|
||||
#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;
|
||||
}
|
|
@ -2,77 +2,29 @@
|
|||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <wayland-client.h>
|
||||
#include <wlr/types.h>
|
||||
#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);
|
||||
}
|
||||
|
|
|
@ -1,64 +0,0 @@
|
|||
#define _XOPEN_SOURCE 500
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <wayland-client.h>
|
||||
#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
|
||||
};
|
|
@ -4,49 +4,89 @@
|
|||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <wayland-client.h>
|
||||
#include <wlr/types.h>
|
||||
#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 = {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -4,6 +4,7 @@
|
|||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
#include <string.h>
|
||||
#include <strings.h>
|
||||
#include <unistd.h>
|
||||
#include <wayland-server.h>
|
||||
#include <wayland-server-protocol.h>
|
||||
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -3,10 +3,12 @@
|
|||
|
||||
#include <wayland-client.h>
|
||||
#include <wayland-server.h>
|
||||
#include <wayland-egl.h>
|
||||
#include <wlr/common/list.h>
|
||||
#include <wlr/wayland.h>
|
||||
#include <wlr/backend/wayland.h>
|
||||
#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;
|
||||
};
|
||||
|
||||
void wlr_wlb_registry_poll(struct wlr_wl_backend *backend);
|
||||
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_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
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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 <wayland-client.h>
|
||||
#include <wayland-server.h>
|
||||
#include <wlr/wayland.h>
|
||||
#include <wlr/backend.h>
|
||||
|
||||
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
|
||||
|
|
|
@ -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;
|
||||
};
|
||||
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in a new issue