hyprwm/wlroots-hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/wlroots-hyprland.git synced 2024-11-22 12:55:58 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #23 from ascent12/cursor

Browse source 
Software cursor + Hardware cursor improvements
This commit is contained in:
Drew DeVault 2017-06-26 18:23:52 -04:00 committed by GitHub
commit ce471f3371
16 changed files with 174 additions and 88 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

91
backend/drm/drm.c
View file

@ -92,13 +92,13 @@ static uint32_t get_fb_for_bo(int fd, struct gbm_bo *bo) {
return *id;
}
static void wlr_drm_output_begin(struct wlr_output_state *output) {
static void wlr_drm_output_make_current(struct wlr_output_state *output) {
struct wlr_drm_renderer *renderer = output->renderer;
eglMakeCurrent(renderer->egl.display, output->egl,
output->egl, renderer->egl.context);
}
static void wlr_drm_output_end(struct wlr_output_state *output) {
static void wlr_drm_output_swap_buffers(struct wlr_output_state *output) {
struct wlr_drm_renderer *renderer = output->renderer;
if (!eglSwapBuffers(renderer->egl.display, output->egl)) {
@ -207,10 +207,10 @@ static void wlr_drm_output_enable(struct wlr_output_state *output, bool enable)
DRM_MODE_DPMS_ON);
// Start rendering loop again by drawing a black frame
wlr_drm_output_begin(output);
wlr_drm_output_make_current(output);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
wlr_drm_output_end(output);
wlr_drm_output_swap_buffers(output);
} else {
drmModeConnectorSetProperty(state->fd, output->connector, output->props.dpms,
DRM_MODE_DPMS_STANDBY);
@ -296,54 +296,65 @@ static void wlr_drm_output_transform(struct wlr_output_state *output,
output->wlr_output->transform = transform;
}
static void wlr_drm_cursor_bo_update(struct wlr_output_state *output,
uint32_t width, uint32_t height) {
if (output->cursor_width == width && output->cursor_height == height) {
return;
}
wlr_log(L_DEBUG, "Allocating new cursor bos");
struct wlr_backend_state *state =
wl_container_of(output->renderer, state, renderer);
for (size_t i = 0; i < 2; ++i) {
output->cursor_bo[i] = gbm_bo_create(state->renderer.gbm,
width, height, GBM_FORMAT_ARGB8888,
GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE);
if (!output->cursor_bo[i]) {
wlr_log(L_ERROR, "Failed to create cursor bo");
return;
}
if (!get_fb_for_bo(state->fd, output->cursor_bo[i])) {
wlr_log(L_ERROR, "Failed to create cursor fb");
return;
}
}
}
static bool wlr_drm_output_set_cursor(struct wlr_output_state *output,
const uint8_t *buf, int32_t stride, uint32_t width, uint32_t height) {
struct wlr_backend_state *state =
wl_container_of(output->renderer, state, renderer);
struct wlr_backend_state *state = wl_container_of(output->renderer, state, renderer);
if (!buf) {
drmModeSetCursor(state->fd, output->crtc, 0, 0, 0);
return true;
}
wlr_drm_cursor_bo_update(output, width, height);
uint64_t bo_width, bo_height;
int ret;
ret = drmGetCap(state->fd, DRM_CAP_CURSOR_WIDTH, &bo_width);
bo_width = ret ? 64 : bo_width;
ret = drmGetCap(state->fd, DRM_CAP_CURSOR_HEIGHT, &bo_height);
bo_height = ret ? 64 : bo_height;
if (width > bo_width || height > bo_width) {
wlr_log(L_INFO, "Cursor too large (max %dx%d)", (int)bo_width, (int)bo_height);
return false;
}
for (int i = 0; i < 2; ++i) {
if (output->cursor_bo[i]) {
continue;
}
output->cursor_bo[i] = gbm_bo_create(state->renderer.gbm, bo_width, bo_height,
GBM_FORMAT_RGBA8888, GBM_BO_USE_CURSOR | GBM_BO_USE_WRITE);
if (!output->cursor_bo[i]) {
wlr_log(L_ERROR, "Failed to create cursor bo");
return false;
}
}
struct gbm_bo *bo;
output->current_cursor ^= 1;
bo = output->cursor_bo[output->current_cursor];
uint32_t _buf[width * height];
memset(_buf, 0, sizeof(_buf));
uint32_t bo_stride = gbm_bo_get_stride(bo);
uint8_t tmp[bo_stride * height];
memset(tmp, 0, sizeof(tmp));
for (size_t i = 0; i < height; ++i) {
memcpy(_buf + i * width,
buf + i * stride,
width * 4);
memcpy(tmp + i * bo_stride, buf + i * stride * 4, width * 4);
}
if (gbm_bo_write(bo, _buf, sizeof(_buf)) < 0) {
if (gbm_bo_write(bo, tmp, sizeof(tmp)) < 0) {
wlr_log(L_ERROR, "Failed to write cursor to bo");
return false;
}
return !drmModeSetCursor(state->fd, output->crtc,
gbm_bo_get_handle(bo).s32, width, height);
uint32_t bo_handle = gbm_bo_get_handle(bo).u32;
if (drmModeSetCursor(state->fd, output->crtc, bo_handle, bo_width, bo_height)) {
wlr_log_errno(L_INFO, "Failed to set hardware cursor");
return false;
}
return true;
}
static bool wlr_drm_output_move_cursor(struct wlr_output_state *output,
@ -365,6 +376,8 @@ static struct wlr_output_impl output_impl = {
.set_cursor = wlr_drm_output_set_cursor,
.move_cursor = wlr_drm_output_move_cursor,
.destroy = wlr_drm_output_destroy,
.make_current = wlr_drm_output_make_current,
.swap_buffers = wlr_drm_output_swap_buffers,
};
static int32_t calculate_refresh_rate(drmModeModeInfo *mode) {
@ -625,9 +638,7 @@ static void page_flip_handler(int fd, unsigned seq,
output->pageflip_pending = false;
if (output->state == DRM_OUTPUT_CONNECTED && state->session->active) {
wlr_drm_output_begin(output);
wl_signal_emit(&output->wlr_output->events.frame, output->wlr_output);
wlr_drm_output_end(output);
}
}

35
backend/wayland/output.c
View file

@ -15,29 +15,34 @@ static void surface_frame_callback(void *data, struct wl_callback *cb, uint32_t
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;
}
wlr_log(L_DEBUG, "frame_callback");
struct wlr_output *wlr_output = output->wlr_output;
wl_signal_emit(&wlr_output->events.frame, wlr_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_make_current(struct wlr_output_state *output) {
wlr_log(L_DEBUG, "make_current");
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());
}
}
static void wlr_wl_output_swap_buffers(struct wlr_output_state *output) {
wlr_log(L_DEBUG, "swap_buffers");
output->frame_callback = wl_surface_frame(output->surface);
wl_callback_add_listener(output->frame_callback, &frame_listener, output);
if (!eglSwapBuffers(output->backend->egl.display, output->egl_surface)) {
wlr_log(L_ERROR, "eglSwapBuffers failed: %s", egl_error());
}
}
static void wlr_wl_output_transform(struct wlr_output_state *output,
enum wl_output_transform transform) {
output->wlr_output->transform = transform;
@ -55,6 +60,8 @@ static void wlr_wl_output_destroy(struct wlr_output_state *output) {
static struct wlr_output_impl output_impl = {
.transform = wlr_wl_output_transform,
.destroy = wlr_wl_output_destroy,
.make_current = wlr_wl_output_make_current,
.swap_buffers = wlr_wl_output_swap_buffers,
};
void handle_ping(void* data, struct wl_shell_surface* ssurface, uint32_t serial) {

36
example/pointer.c
View file

@ -21,9 +21,7 @@
#include "cat.h"
struct sample_state {
struct wlr_renderer *renderer;
struct wlr_surface *cat_texture;
int cur_x, cur_y;
double cur_x, cur_y;
float default_color[4];
float clear_color[4];
};
@ -33,18 +31,13 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
struct sample_state *sample = state->data;
struct wlr_output *wlr_output = output->output;
wlr_renderer_begin(sample->renderer, wlr_output);
wlr_output_make_current(wlr_output);
glClearColor(sample->clear_color[0], sample->clear_color[1],
sample->clear_color[2], sample->clear_color[3]);
glClear(GL_COLOR_BUFFER_BIT);
float matrix[16];
wlr_surface_get_matrix(sample->cat_texture, &matrix,
&wlr_output->transform_matrix, sample->cur_x, sample->cur_y);
wlr_render_with_matrix(sample->renderer,
sample->cat_texture, &matrix);
wlr_renderer_end(sample->renderer);
wlr_output_swap_buffers(wlr_output);
}
static void handle_pointer_motion(struct pointer_state *pstate,
@ -52,6 +45,11 @@ static void handle_pointer_motion(struct pointer_state *pstate,
struct sample_state *state = pstate->compositor->data;
state->cur_x += d_x;
state->cur_y += d_y;
struct output_state *output;
wl_list_for_each(output, &pstate->compositor->outputs, link) {
wlr_output_move_cursor(output->output, state->cur_x, state->cur_y);
}
}
static void handle_pointer_motion_absolute(struct pointer_state *pstate,
@ -59,6 +57,11 @@ static void handle_pointer_motion_absolute(struct pointer_state *pstate,
struct sample_state *state = pstate->compositor->data;
state->cur_x = x;
state->cur_y = y;
struct output_state *output;
wl_list_for_each(output, &pstate->compositor->outputs, link) {
wlr_output_move_cursor(output->output, state->cur_x, state->cur_y);
}
}
static void handle_pointer_button(struct pointer_state *pstate,
@ -95,9 +98,8 @@ static void handle_pointer_axis(struct pointer_state *pstate,
static void handle_output_add(struct output_state *ostate) {
struct wlr_output *wlr_output = ostate->output;
int width = 16, height = 16;
if (!wlr_output_set_cursor(wlr_output, cat_tex.pixel_data,
width * 4, width, height)) {
cat_tex.width, cat_tex.width, cat_tex.height)) {
wlr_log(L_DEBUG, "Failed to set hardware cursor");
return;
}
@ -121,13 +123,5 @@ int main(int argc, char *argv[]) {
compositor.pointer_axis_cb = handle_pointer_axis;
compositor_init(&compositor);
state.renderer = wlr_gles2_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_run(&compositor);
wlr_surface_destroy(state.cat_texture);
wlr_renderer_destroy(state.renderer);
}

4
example/rotation.c
View file

@ -46,6 +46,7 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
int32_t width, height;
wlr_output_effective_resolution(wlr_output, &width, &height);
wlr_output_make_current(wlr_output);
wlr_renderer_begin(sample->renderer, wlr_output);
float matrix[16];
@ -59,6 +60,7 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
}
wlr_renderer_end(sample->renderer);
wlr_output_swap_buffers(wlr_output);
long ms = (ts->tv_sec - output->last_frame.tv_sec) * 1000 +
(ts->tv_nsec - output->last_frame.tv_nsec) / 1000000;
@ -205,7 +207,7 @@ int main(int argc, char *argv[]) {
state.renderer = wlr_gles2_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);
cat_tex.width, cat_tex.width, cat_tex.height, cat_tex.pixel_data);
compositor_run(&compositor);

4
example/simple.c
View file

@ -34,8 +34,12 @@ void handle_output_frame(struct output_state *output, struct timespec *ts) {
sample->dec = inc;
}
wlr_output_make_current(output->output);
glClearColor(sample->color[0], sample->color[1], sample->color[2], 1.0);
glClear(GL_COLOR_BUFFER_BIT);
wlr_output_swap_buffers(output->output);
}
int main() {

2
example/tablet.c
View file

@ -41,6 +41,7 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
int32_t width, height;
wlr_output_effective_resolution(wlr_output, &width, &height);
wlr_output_make_current(wlr_output);
wlr_renderer_begin(sample->renderer, wlr_output);
float matrix[16], view[16];
@ -74,6 +75,7 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
}
wlr_renderer_end(sample->renderer);
wlr_output_swap_buffers(wlr_output);
}
static void handle_tool_axis(struct tablet_tool_state *tstate,

5
example/touch.c
View file

@ -38,6 +38,8 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
int32_t width, height;
wlr_output_effective_resolution(wlr_output, &width, &height);
wlr_output_make_current(wlr_output);
wlr_renderer_begin(sample->renderer, wlr_output);
float matrix[16];
@ -52,6 +54,7 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
}
wlr_renderer_end(sample->renderer);
wlr_output_swap_buffers(wlr_output);
}
static void handle_touch_down(struct touch_state *tstate, int32_t slot,
@ -104,7 +107,7 @@ int main(int argc, char *argv[]) {
state.renderer = wlr_gles2_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);
cat_tex.width, cat_tex.width, cat_tex.height, cat_tex.pixel_data);
compositor_run(&compositor);

2
include/wlr/interfaces/wlr_output.h
View file

@ -13,6 +13,8 @@ struct wlr_output_impl {
const uint8_t *buf, int32_t stride, uint32_t width, uint32_t height);
bool (*move_cursor)(struct wlr_output_state *state, int x, int y);
void (*destroy)(struct wlr_output_state *state);
void (*make_current)(struct wlr_output_state *state);
void (*swap_buffers)(struct wlr_output_state *state);
};
struct wlr_output *wlr_output_create(struct wlr_output_impl *impl,

2
include/wlr/render.h
View file

@ -59,7 +59,7 @@ struct wlr_surface {
* calling this function.
*/
bool wlr_surface_attach_pixels(struct wlr_surface *surf, uint32_t format,
int width, int height, const unsigned char *pixels);
int stride, int width, int height, const unsigned char *pixels);
/**
* Attaches pixels from a wl_shm_buffer to this surface. The shm buffer may be
* invalidated after calling this function.

2
include/wlr/render/interface.h
View file

@ -31,7 +31,7 @@ struct wlr_renderer *wlr_renderer_init(struct wlr_renderer_state *state,
struct wlr_surface_impl {
bool (*attach_pixels)(struct wlr_surface_state *state, uint32_t format,
int width, int height, const unsigned char *pixels);
int stride, int width, int height, const unsigned char *pixels);
bool (*attach_shm)(struct wlr_surface_state *state, uint32_t format,
struct wl_shm_buffer *shm);
// TODO: egl

10
include/wlr/types/wlr_output.h
View file

@ -42,6 +42,14 @@ struct wlr_output {
struct wl_signal frame;
struct wl_signal resolution;
} events;
struct {
bool is_sw;
int32_t x, y;
uint32_t width, height;
struct wlr_renderer *renderer;
struct wlr_surface *texture;
} cursor;
};
void wlr_output_enable(struct wlr_output *output, bool enable);
@ -55,5 +63,7 @@ bool wlr_output_move_cursor(struct wlr_output *output, int x, int y);
void wlr_output_destroy(struct wlr_output *output);
void wlr_output_effective_resolution(struct wlr_output *output,
int *width, int *height);
void wlr_output_make_current(struct wlr_output *output);
void wlr_output_swap_buffers(struct wlr_output *output);
#endif

4
render/CMakeLists.txt
View file

@ -1,5 +1,5 @@
add_library(wlr-render STATIC
matrix.c
add_library(wlr-render
matrix.c
wlr_renderer.c
wlr_surface.c
gles2/shaders.c

5
render/gles2/surface.c
View file

@ -2,6 +2,7 @@
#include <stdlib.h>
#include <assert.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <wayland-util.h>
#include <wayland-server-protocol.h>
#include <wlr/render.h>
@ -10,15 +11,17 @@
#include "render/gles2.h"
static bool gles2_surface_attach_pixels(struct wlr_surface_state *surface,
uint32_t format, int width, int height, const unsigned char *pixels) {
uint32_t format, int stride, int width, int height, const unsigned char *pixels) {
assert(surface);
surface->wlr_surface->width = width;
surface->wlr_surface->height = height;
surface->wlr_surface->format = format;
GL_CALL(glGenTextures(1, &surface->tex_id));
GL_CALL(glBindTexture(GL_TEXTURE_2D, surface->tex_id));
GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, stride));
GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0,
format, GL_UNSIGNED_BYTE, pixels));
GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, 0));
surface->wlr_surface->valid = true;
return true;
}

4
render/wlr_surface.c
View file

@ -20,9 +20,9 @@ void wlr_surface_bind(struct wlr_surface *surface) {
}
bool wlr_surface_attach_pixels(struct wlr_surface *surface, uint32_t format,
int width, int height, const unsigned char *pixels) {
int stride, int width, int height, const unsigned char *pixels) {
return surface->impl->attach_pixels(surface->state,
format, width, height, pixels);
format, stride, width, height, pixels);
}
bool wlr_surface_attach_shm(struct wlr_surface *surface, uint32_t format,

1
types/CMakeLists.txt
View file

@ -15,5 +15,6 @@ add_library(wlr-types
target_link_libraries(wlr-types
wlr-util
wlr-render
${WAYLAND_LIBRARIES}
)

55
types/wlr_output.c
View file

@ -7,6 +7,10 @@
#include <wlr/interfaces/wlr_output.h>
#include <wlr/util/list.h>
#include <wlr/util/log.h>
#include <GLES2/gl2.h>
#include <wlr/render/matrix.h>
#include <wlr/render/gles2.h>
#include <wlr/render.h>
static void wl_output_send_to_resource(struct wl_resource *resource) {
assert(resource);
@ -182,16 +186,44 @@ void wlr_output_transform(struct wlr_output *output,
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;
if (output->impl->set_cursor && output->impl->set_cursor(output->state, buf,
stride, width, height)) {
output->cursor.is_sw = false;
return true;
}
return output->impl->set_cursor(output->state, buf, stride, width, height);
wlr_log(L_INFO, "Falling back to software cursor");
output->cursor.is_sw = true;
output->cursor.width = width;
output->cursor.height = height;
if (!output->cursor.renderer) {
output->cursor.renderer = wlr_gles2_renderer_init();
}
if (!output->cursor.texture) {
output->cursor.texture = wlr_render_surface_init(output->cursor.renderer);
}
wlr_surface_attach_pixels(output->cursor.texture, GL_RGBA,
stride, width, height, buf);
return true;
}
bool wlr_output_move_cursor(struct wlr_output *output, int x, int y) {
if (!output->impl || !output->impl->move_cursor) {
output->cursor.x = x;
output->cursor.y = y;
if (output->cursor.is_sw) {
return true;
}
if (!output->impl->move_cursor) {
return false;
}
return output->impl->move_cursor(output->state, x, y);
}
@ -216,3 +248,18 @@ void wlr_output_effective_resolution(struct wlr_output *output,
*height = output->height;
}
}
void wlr_output_make_current(struct wlr_output *output) {
output->impl->make_current(output->state);
}
void wlr_output_swap_buffers(struct wlr_output *output) {
if (output->cursor.is_sw) {
float matrix[16];
wlr_surface_get_matrix(output->cursor.texture, &matrix, &output->transform_matrix,
output->cursor.x, output->cursor.y);
wlr_render_with_matrix(output->cursor.renderer, output->cursor.texture, &matrix);
}
output->impl->swap_buffers(output->state);
}