diff options
Diffstat (limited to 'gfx/wr/example-compositor/compositor-wayland/src')
| -rw-r--r-- | gfx/wr/example-compositor/compositor-wayland/src/lib.cpp | 772 | ||||
| -rw-r--r-- | gfx/wr/example-compositor/compositor-wayland/src/lib.rs | 269 |
2 files changed, 1041 insertions, 0 deletions
diff --git a/gfx/wr/example-compositor/compositor-wayland/src/lib.cpp b/gfx/wr/example-compositor/compositor-wayland/src/lib.cpp new file mode 100644 index 0000000000..5529c987a9 --- /dev/null +++ b/gfx/wr/example-compositor/compositor-wayland/src/lib.cpp @@ -0,0 +1,772 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#define UNICODE + +#include <algorithm> +#include <assert.h> +#include <errno.h> +#include <fcntl.h> +#include <map> +#include <math.h> +#include <stdio.h> +#include <string.h> +#include <sys/mman.h> +#include <unistd.h> +#include <unordered_map> +#include <vector> + +#include <wayland-client.h> +#include <wayland-egl.h> + +#include <EGL/egl.h> +#include <EGL/eglext.h> +#include <GL/gl.h> +#include <GLES2/gl2.h> + +#include "viewporter-client-protocol.h" +#include "xdg-shell-client-protocol.h" + +#define UNUSED(x) (void)(x) + +#define MIN(x, y) (((x) < (y)) ? (x) : (y)) +#define MAX(x, y) (((x) > (y)) ? (x) : (y)) + +#define NUM_QUERIES 2 + +#define VIRTUAL_OFFSET 512 * 1024 + +enum SyncMode { + None_ = 0, + Swap = 1, + Commit = 2, + Flush = 3, + Query = 4, +}; + +// The OS compositor representation of a picture cache tile. +struct Tile { + uint64_t surface_id; + int x; + int y; + + struct wl_surface* surface; + struct wl_subsurface* subsurface; + struct wp_viewport* viewport; + struct wl_egl_window* egl_window; + EGLSurface egl_surface; + bool is_visible; + + std::vector<EGLint> damage_rects; +}; + +struct TileKey { + int x; + int y; + + TileKey(int ax, int ay) : x(ax), y(ay) {} +}; + +bool operator==(const TileKey& k0, const TileKey& k1) { + return k0.x == k1.x && k0.y == k1.y; +} + +struct TileKeyHasher { + size_t operator()(const TileKey& key) const { return key.x ^ key.y; } +}; + +struct Surface { + uint64_t id; + int tile_width; + int tile_height; + bool is_opaque; + std::unordered_map<TileKey, Tile*, TileKeyHasher> tiles; +}; + +struct WLDisplay { + struct wl_display* display; + struct wl_registry* registry; + struct wl_compositor* compositor; + struct wl_subcompositor* subcompositor; + struct xdg_wm_base* wm_base; + struct wl_seat* seat; + struct wl_pointer* pointer; + struct wl_touch* touch; + struct wl_keyboard* keyboard; + struct wl_shm* shm; + struct wl_cursor_theme* cursor_theme; + struct wl_cursor* default_cursor; + struct wl_surface* cursor_surface; + struct wp_viewporter* viewporter; + + PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC swap_buffers_with_damage; +}; + +struct WLGeometry { + int width, height; +}; + +struct WLWindow { + WLGeometry geometry; + bool enable_compositor; + SyncMode sync_mode; + bool closed; + + WLDisplay* display; + struct wl_surface* surface; + struct xdg_surface* xdg_surface; + struct xdg_toplevel* xdg_toplevel; + struct wl_callback* callback; + struct wp_viewport* viewport; + bool wait_for_configure; + + struct wl_egl_window* egl_window; + EGLSurface egl_surface; + + EGLDeviceEXT eglDevice; + EGLDisplay eglDisplay; + EGLContext eglContext; + EGLConfig config; + + // Maintain list of layer state between frames to avoid visual tree rebuild. + std::vector<uint64_t> currentLayers; + std::vector<uint64_t> prevLayers; + + // Maps WR surface IDs to each OS surface + std::unordered_map<uint64_t, Surface> surfaces; + std::vector<Tile*> destroyedTiles; + std::vector<Tile*> hiddenTiles; +}; + +extern "C" { + +static void init_wl_registry(WLWindow* window); +static void init_xdg_window(WLWindow* window); + +WLWindow* com_wl_create_window(int width, int height, bool enable_compositor, + SyncMode sync_mode) { + WLDisplay* display = new WLDisplay; + WLWindow* window = new WLWindow; + + window->display = display; + window->geometry.width = width; + window->geometry.height = height; + window->enable_compositor = enable_compositor; + window->sync_mode = sync_mode; + window->closed = false; + + display->display = wl_display_connect(NULL); + assert(display->display); + + init_wl_registry(window); + if (enable_compositor && !display->viewporter) { + fprintf(stderr, "Native compositor mode requires wp_viewporter support\n"); + window->closed = true; + } + + window->eglDisplay = + eglGetPlatformDisplay(EGL_PLATFORM_WAYLAND_KHR, display->display, NULL); + + eglInitialize(window->eglDisplay, nullptr, nullptr); + eglBindAPI(EGL_OPENGL_API); + + EGLint num_configs = 0; + EGLint cfg_attribs[] = {EGL_SURFACE_TYPE, + EGL_WINDOW_BIT, + EGL_RENDERABLE_TYPE, + EGL_OPENGL_BIT, + EGL_RED_SIZE, + 8, + EGL_GREEN_SIZE, + 8, + EGL_BLUE_SIZE, + 8, + EGL_ALPHA_SIZE, + 8, + EGL_DEPTH_SIZE, + 24, + EGL_NONE}; + EGLConfig configs[32]; + + eglChooseConfig(window->eglDisplay, cfg_attribs, configs, + sizeof(configs) / sizeof(EGLConfig), &num_configs); + assert(num_configs > 0); + window->config = configs[0]; + + EGLint ctx_attribs[] = {EGL_CONTEXT_OPENGL_PROFILE_MASK, + EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT, + EGL_CONTEXT_MAJOR_VERSION, + 3, + EGL_CONTEXT_MINOR_VERSION, + 2, + EGL_NONE}; + + // Create an EGL context that can be used for drawing + window->eglContext = eglCreateContext(window->eglDisplay, window->config, + EGL_NO_CONTEXT, ctx_attribs); + + window->surface = wl_compositor_create_surface(display->compositor); + init_xdg_window(window); + + struct wl_region* region = + wl_compositor_create_region(window->display->compositor); + wl_region_add(region, 0, 0, INT32_MAX, INT32_MAX); + wl_surface_set_opaque_region(window->surface, region); + wl_region_destroy(region); + + if (enable_compositor) { + xdg_toplevel_set_title(window->xdg_toplevel, + "example-compositor (Wayland)"); + } else { + xdg_toplevel_set_title(window->xdg_toplevel, "example-compositor (Simple)"); + } + + window->wait_for_configure = true; + wl_surface_commit(window->surface); + + EGLBoolean ok = eglMakeCurrent(window->eglDisplay, EGL_NO_SURFACE, + EGL_NO_SURFACE, window->eglContext); + assert(ok); + + display->swap_buffers_with_damage = + (PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)eglGetProcAddress( + "eglSwapBuffersWithDamageKHR"); + + return window; +} + +bool com_wl_tick(WLWindow* window) { + if (window->wait_for_configure) { + int ret = 0; + while (window->wait_for_configure && !window->closed && ret != -1) { + wl_display_dispatch(window->display->display); + } + } else { + wl_display_dispatch_pending(window->display->display); + } + + return !window->closed; +} + +static void unmap_hidden_tiles(WLWindow* window) { + for (Tile* tile : window->hiddenTiles) { + if (tile->subsurface) { + wl_subsurface_destroy(tile->subsurface); + tile->subsurface = nullptr; + } + } + window->hiddenTiles.clear(); +} + +static void clean_up_tiles(WLWindow* window) { + for (Tile* tile : window->destroyedTiles) { + eglDestroySurface(window->eglDisplay, tile->egl_surface); + wl_egl_window_destroy(tile->egl_window); + wp_viewport_destroy(tile->viewport); + wl_surface_destroy(tile->surface); + delete tile; + } + window->destroyedTiles.clear(); +} + +static void handle_callback(void* data, struct wl_callback* callback, + uint32_t time) { + WLWindow* window = (WLWindow*)data; + UNUSED(time); + + assert(window->callback == callback); + + wl_callback_destroy(callback); + window->callback = nullptr; +} + +static const struct wl_callback_listener frame_listener = {handle_callback}; + +void com_wl_swap_buffers(WLWindow* window) { + if (window->enable_compositor) { + for (auto surface_it = window->surfaces.begin(); + surface_it != window->surfaces.end(); ++surface_it) { + Surface* surface = &surface_it->second; + + for (auto tile_it = surface->tiles.begin(); + tile_it != surface->tiles.end(); ++tile_it) { + Tile* tile = tile_it->second; + + if (!tile->damage_rects.empty() && tile->is_visible) { + eglMakeCurrent(window->eglDisplay, tile->egl_surface, + tile->egl_surface, window->eglContext); + eglSwapInterval(window->eglDisplay, 0); + + /* if (window->display->swap_buffers_with_damage) { + window->display->swap_buffers_with_damage( + window->eglDisplay, tile->egl_surface, + tile->damage_rects.data(), tile->damage_rects.size() / 4); + } else */ + eglSwapBuffers(window->eglDisplay, tile->egl_surface); + tile->damage_rects.clear(); + + eglMakeCurrent(window->eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, + window->eglContext); + } else { + wl_surface_commit(tile->surface); + } + } + } + wl_surface_commit(window->surface); + unmap_hidden_tiles(window); + clean_up_tiles(window); + + int ret = 0; + switch (window->sync_mode) { + case SyncMode::None_: + wl_display_roundtrip(window->display->display); + break; + case SyncMode::Swap: + window->callback = wl_surface_frame(window->surface); + wl_callback_add_listener(window->callback, &frame_listener, window); + wl_surface_commit(window->surface); + + while (window->callback && !window->closed && ret != -1) { + ret = wl_display_dispatch(window->display->display); + } + break; + default: + assert(false); + break; + } + } else { + // If not using native mode, then do a normal EGL swap buffers. + switch (window->sync_mode) { + case SyncMode::None_: + eglSwapInterval(window->eglDisplay, 0); + break; + case SyncMode::Swap: + eglSwapInterval(window->eglDisplay, 1); + break; + default: + assert(false); + break; + } + eglSwapBuffers(window->eglDisplay, window->egl_surface); + } +} + +// Create a new native surface +void com_wl_create_surface(WLWindow* window, uint64_t surface_id, + int tile_width, int tile_height, bool is_opaque) { + assert(window->surfaces.count(surface_id) == 0); + + Surface surface; + surface.id = surface_id; + surface.tile_width = tile_width; + surface.tile_height = tile_height; + surface.is_opaque = is_opaque; + + window->surfaces.emplace(surface_id, surface); +} + +void com_wl_create_tile(WLWindow* window, uint64_t surface_id, int x, int y) { + WLDisplay* display = window->display; + + assert(window->surfaces.count(surface_id) == 1); + Surface* surface = &window->surfaces.at(surface_id); + + TileKey key(x, y); + assert(surface->tiles.count(key) == 0); + + Tile* tile = new Tile; + tile->surface_id = surface_id; + tile->x = x; + tile->y = y; + tile->is_visible = false; + + tile->surface = wl_compositor_create_surface(display->compositor); + tile->viewport = + wp_viewporter_get_viewport(display->viewporter, tile->surface); + + if (surface->is_opaque) { + struct wl_region* region = + wl_compositor_create_region(window->display->compositor); + wl_region_add(region, 0, 0, INT32_MAX, INT32_MAX); + wl_surface_set_opaque_region(tile->surface, region); + wl_region_destroy(region); + } + + tile->egl_window = wl_egl_window_create(tile->surface, surface->tile_width, + surface->tile_height); + tile->egl_surface = eglCreateWindowSurface(window->eglDisplay, window->config, + tile->egl_window, NULL); + assert(tile->egl_surface != EGL_NO_SURFACE); + + surface->tiles.emplace(key, tile); +} + +static void show_tile(WLWindow* window, Tile* tile) { + if (tile->is_visible) { + assert(tile->subsurface); + return; + } + + tile->subsurface = wl_subcompositor_get_subsurface( + window->display->subcompositor, tile->surface, window->surface); + + /* This is not comprehensive yet, see hide_tile() */ + Surface* surface = &window->surfaces.at(tile->surface_id); + for (auto tile_it = surface->tiles.begin(); tile_it != surface->tiles.end(); + ++tile_it) { + Tile* other_tile = tile_it->second; + + if (other_tile->is_visible) { + wl_subsurface_place_above(tile->subsurface, other_tile->surface); + } + } + + tile->is_visible = true; +} + +static void hide_tile(WLWindow* window, Tile* tile) { + if (!tile->is_visible) { + return; + } + + /* + * This is a workaround for missing API on the egl-wayland platform. We + * likely want to replace it a solution that detaches the buffer from + * the surface, which would require us to manage buffers manually. + */ + wl_subsurface_set_position(tile->subsurface, window->geometry.width / 2, + window->geometry.height / 2); + wp_viewport_set_source(tile->viewport, wl_fixed_from_int(0), + wl_fixed_from_int(0), wl_fixed_from_int(1), + wl_fixed_from_int(1)); + wl_subsurface_place_below(tile->subsurface, window->surface); + tile->is_visible = false; + window->hiddenTiles.push_back(tile); +} + +void com_wl_destroy_tile(WLWindow* window, uint64_t surface_id, int x, int y) { + assert(window->surfaces.count(surface_id) == 1); + + Surface* surface = &window->surfaces.at(surface_id); + TileKey key(x, y); + assert(surface->tiles.count(key) == 1); + Tile* tile = surface->tiles[key]; + + hide_tile(window, tile); + wl_surface_commit(tile->surface); + + window->destroyedTiles.push_back(tile); + surface->tiles.erase(key); +} + +void com_wl_destroy_surface(WLWindow* window, uint64_t surface_id) { + assert(window->surfaces.count(surface_id) == 1); + + Surface* surface = &window->surfaces.at(surface_id); + for (auto tile_it = surface->tiles.begin(); tile_it != surface->tiles.end(); + tile_it = surface->tiles.begin()) { + Tile* tile = tile_it->second; + + com_wl_destroy_tile(window, surface_id, tile->x, tile->y); + } + + window->surfaces.erase(surface_id); +} + +void com_wl_destroy_window(WLWindow* window) { + for (auto surface_it = window->surfaces.begin(); + surface_it != window->surfaces.end(); ++surface_it) { + Surface& surface = surface_it->second; + + com_wl_destroy_surface(window, surface.id); + } + + if (window->egl_surface != EGL_NO_SURFACE) { + eglDestroySurface(window->eglDisplay, window->egl_surface); + } + eglDestroyContext(window->eglDisplay, window->eglContext); + eglTerminate(window->eglDisplay); + + delete window; +} + +// Bind a native surface to allow issuing GL commands to it +GLuint com_wl_bind_surface(WLWindow* window, uint64_t surface_id, int tile_x, + int tile_y, int* x_offset, int* y_offset, + int dirty_x0, int dirty_y0, int dirty_width, + int dirty_height) { + *x_offset = 0; + *y_offset = 0; + + assert(window->surfaces.count(surface_id) == 1); + Surface* surface = &window->surfaces[surface_id]; + + TileKey key(tile_x, tile_y); + assert(surface->tiles.count(key) == 1); + Tile* tile = surface->tiles[key]; + + tile->damage_rects.push_back(dirty_x0); + tile->damage_rects.push_back(dirty_y0); + tile->damage_rects.push_back(dirty_width); + tile->damage_rects.push_back(dirty_height); + + EGLBoolean ok = eglMakeCurrent(window->eglDisplay, tile->egl_surface, + tile->egl_surface, window->eglContext); + assert(ok); + + return 0; +} + +// Unbind a currently bound native surface +void com_wl_unbind_surface(WLWindow* window) { + eglMakeCurrent(window->eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, + window->eglContext); +} + +void com_wl_begin_transaction(WLWindow*) {} + +// Add a native surface to the visual tree. Called per-frame to build the +// composition. +void com_wl_add_surface(WLWindow* window, uint64_t surface_id, int offset_x, + int offset_y, int clip_x, int clip_y, int clip_w, + int clip_h) { + Surface* surface = &window->surfaces[surface_id]; + window->currentLayers.push_back(surface_id); + + for (auto tile_it = surface->tiles.begin(); tile_it != surface->tiles.end(); + ++tile_it) { + Tile* tile = tile_it->second; + + int pos_x = MAX((tile->x * surface->tile_width) + offset_x, clip_x); + int pos_y = MAX((tile->y * surface->tile_height) + offset_y, clip_y); + + float view_x = MAX((clip_x - offset_x) - tile->x * surface->tile_width, 0); + float view_y = MAX((clip_y - offset_y) - tile->y * surface->tile_height, 0); + + float view_w = MIN(surface->tile_width - view_x, (clip_x + clip_w) - pos_x); + float view_h = + MIN(surface->tile_height - view_y, (clip_y + clip_h) - pos_y); + view_w = MIN(window->geometry.width - pos_x, view_w); + view_h = MIN(window->geometry.height - pos_y, view_h); + + if (view_w > 0 && view_h > 0) { + show_tile(window, tile); + + wl_surface_set_buffer_transform(tile->surface, + WL_OUTPUT_TRANSFORM_FLIPPED_180); + wl_subsurface_set_position(tile->subsurface, pos_x, pos_y); + wp_viewport_set_source(tile->viewport, wl_fixed_from_double(view_x), + wl_fixed_from_double(view_y), + wl_fixed_from_double(view_w), + wl_fixed_from_double(view_h)); + } else { + hide_tile(window, tile); + } + } +} + +void com_wl_end_transaction(WLWindow* window) { + bool same = window->prevLayers == window->currentLayers; + if (!same) { + struct wl_surface* prev_surface = window->surface; + + for (auto it = window->currentLayers.begin(); + it != window->currentLayers.end(); ++it) { + Surface* surface = &window->surfaces[*it]; + + struct wl_surface* next_surface = nullptr; + for (auto tile_it = surface->tiles.begin(); + tile_it != surface->tiles.end(); ++tile_it) { + Tile* tile = tile_it->second; + + if (tile->is_visible) { + wl_subsurface_place_above(tile->subsurface, prev_surface); + + if (!next_surface) { + next_surface = tile->surface; + } + } + } + prev_surface = next_surface; + } + } + + window->prevLayers.swap(window->currentLayers); + window->currentLayers.clear(); +} + +void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, + const GLenum* attachments) { + UNUSED(target); + UNUSED(numAttachments); + UNUSED(attachments); +} + +// Get a pointer to an EGL symbol +void* com_wl_get_proc_address(const char* name) { + /* Disable glInvalidateFramebuffer for now as it triggers errors. + * This is likely due to the egl-wayland platform, which we may want to + * replace with a custom implementation in order to have more control + * over the low-lever bits. + */ + if (strcmp(name, "glInvalidateFramebuffer") == 0) { + return (void*)glInvalidateFramebuffer; + } + + return (void*)eglGetProcAddress(name); +} + +void com_wl_deinit(WLWindow* window) { UNUSED(window); } + +static void handle_xdg_surface_configure(void* data, + struct xdg_surface* surface, + uint32_t serial) { + WLWindow* window = (WLWindow*)data; + + xdg_surface_ack_configure(surface, serial); + + if (window->wait_for_configure) { + if (window->enable_compositor) { + int width = window->geometry.width; + int height = window->geometry.height; + + window->egl_window = wl_egl_window_create(window->surface, 1, 1); + window->egl_surface = eglCreateWindowSurface( + window->eglDisplay, window->config, window->egl_window, NULL); + assert(window->egl_surface != EGL_NO_SURFACE); + + EGLBoolean ok = eglMakeCurrent(window->eglDisplay, window->egl_surface, + window->egl_surface, window->eglContext); + assert(ok); + + glClearColor(1.0, 1.0, 1.0, 1.0); + glClear(GL_COLOR_BUFFER_BIT); + + window->viewport = wp_viewporter_get_viewport(window->display->viewporter, + window->surface); + wp_viewport_set_destination(window->viewport, width, height); + + eglSwapBuffers(window->eglDisplay, window->egl_surface); + } else { + window->egl_window = wl_egl_window_create( + window->surface, window->geometry.width, window->geometry.height); + window->egl_surface = eglCreateWindowSurface( + window->eglDisplay, window->config, window->egl_window, NULL); + assert(window->egl_surface != EGL_NO_SURFACE); + + EGLBoolean ok = eglMakeCurrent(window->eglDisplay, window->egl_surface, + window->egl_surface, window->eglContext); + assert(ok); + } + } + + window->wait_for_configure = false; +} + +static const struct xdg_surface_listener xdg_surface_listener = { + handle_xdg_surface_configure}; + +static void handle_xdg_toplevel_configure(void* data, + struct xdg_toplevel* toplevel, + int32_t width, int32_t height, + struct wl_array* states) { + WLWindow* window = (WLWindow*)data; + UNUSED(toplevel); + UNUSED(states); + + if (width > 0 && height > 0) { + window->geometry.width = width; + window->geometry.height = height; + + if (!window->wait_for_configure) { + if (window->enable_compositor) { + wp_viewport_set_destination(window->viewport, window->geometry.width, + window->geometry.height); + } else { + wl_egl_window_resize(window->egl_window, window->geometry.width, + window->geometry.height, 0, 0); + } + } + } +} + +static void handle_xdg_toplevel_close(void* data, + struct xdg_toplevel* toplevel) { + UNUSED(toplevel); + WLWindow* window = (WLWindow*)data; + window->closed = true; +} + +static const struct xdg_toplevel_listener xdg_toplevel_listener = { + handle_xdg_toplevel_configure, + handle_xdg_toplevel_close, +}; + +static void xdg_wm_base_ping(void* data, struct xdg_wm_base* shell, + uint32_t serial) { + UNUSED(data); + xdg_wm_base_pong(shell, serial); +} + +static const struct xdg_wm_base_listener wm_base_listener = { + xdg_wm_base_ping, +}; + +static void registry_handle_global(void* data, struct wl_registry* registry, + uint32_t name, const char* interface, + uint32_t version) { + WLDisplay* d = (WLDisplay*)data; + + if (strcmp(interface, "wl_compositor") == 0) { + d->compositor = (struct wl_compositor*)wl_registry_bind( + registry, name, &wl_compositor_interface, MIN(version, 4)); + } else if (strcmp(interface, "wp_viewporter") == 0) { + d->viewporter = (struct wp_viewporter*)wl_registry_bind( + registry, name, &wp_viewporter_interface, 1); + } else if (strcmp(interface, "xdg_wm_base") == 0) { + d->wm_base = (struct xdg_wm_base*)wl_registry_bind( + registry, name, &xdg_wm_base_interface, 1); + xdg_wm_base_add_listener(d->wm_base, &wm_base_listener, NULL); + } else if (strcmp(interface, "wl_subcompositor") == 0) { + d->subcompositor = (struct wl_subcompositor*)wl_registry_bind( + registry, name, &wl_subcompositor_interface, 1); + } +} + +static void registry_handle_global_remove(void* data, + struct wl_registry* registry, + uint32_t name) { + UNUSED(data); + UNUSED(registry); + UNUSED(name); +} + +static const struct wl_registry_listener registry_listener = { + registry_handle_global, registry_handle_global_remove}; + +static void init_wl_registry(WLWindow* window) { + WLDisplay* display = window->display; + + display->registry = wl_display_get_registry(display->display); + wl_registry_add_listener(display->registry, ®istry_listener, display); + + wl_display_roundtrip(display->display); + + assert(display->compositor); + assert(display->wm_base); + assert(display->subcompositor); +} + +static void init_xdg_window(WLWindow* window) { + window->xdg_surface = + xdg_wm_base_get_xdg_surface(window->display->wm_base, window->surface); + assert(window->xdg_surface); + xdg_surface_add_listener(window->xdg_surface, &xdg_surface_listener, window); + + window->xdg_toplevel = xdg_surface_get_toplevel(window->xdg_surface); + xdg_toplevel_add_listener(window->xdg_toplevel, &xdg_toplevel_listener, + window); + assert(window->xdg_toplevel); +} +} diff --git a/gfx/wr/example-compositor/compositor-wayland/src/lib.rs b/gfx/wr/example-compositor/compositor-wayland/src/lib.rs new file mode 100644 index 0000000000..daddbb6495 --- /dev/null +++ b/gfx/wr/example-compositor/compositor-wayland/src/lib.rs @@ -0,0 +1,269 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use std::os::raw::{c_void, c_char}; + +/* + + This is a very simple (and unsafe!) rust wrapper for the Wayland / EGL + implementation in lib.cpp. + + It just proxies the calls from the Compositor impl to the C99 code. This is very + hacky and not suitable for production! + + */ + +// Opaque wrapper for the Window type in lib.cpp +#[repr(C)] +pub struct Window { + _unused: [u8; 0] +} + +// C99 functions that do the compositor work +extern { + fn com_wl_create_window( + width: i32, + height: i32, + enable_compositor: bool, + sync_mode: i32, + ) -> *mut Window; + fn com_wl_destroy_window(window: *mut Window); + fn com_wl_tick(window: *mut Window) -> bool; + fn com_wl_get_proc_address(name: *const c_char) -> *const c_void; + fn com_wl_swap_buffers(window: *mut Window); + + fn com_wl_create_surface( + window: *mut Window, + id: u64, + tile_width: i32, + tile_height: i32, + is_opaque: bool, + ); + + fn com_wl_create_tile( + window: *mut Window, + id: u64, + x: i32, + y: i32, + ); + + fn com_wl_destroy_tile( + window: *mut Window, + id: u64, + x: i32, + y: i32, + ); + + fn com_wl_destroy_surface( + window: *mut Window, + id: u64, + ); + + fn com_wl_bind_surface( + window: *mut Window, + surface_id: u64, + tile_x: i32, + tile_y: i32, + x_offset: &mut i32, + y_offset: &mut i32, + dirty_x0: i32, + dirty_y0: i32, + dirty_width: i32, + dirty_height: i32, + ) -> u32; + fn com_wl_unbind_surface(window: *mut Window); + + fn com_wl_begin_transaction(window: *mut Window); + + fn com_wl_add_surface( + window: *mut Window, + id: u64, + x: i32, + y: i32, + clip_x: i32, + clip_y: i32, + clip_w: i32, + clip_h: i32, + ); + + fn com_wl_end_transaction(window: *mut Window); + + fn com_wl_deinit(window: *mut Window); +} + +pub fn create_window( + width: i32, + height: i32, + enable_compositor: bool, + sync_mode: i32, +) -> *mut Window { + unsafe { + com_wl_create_window(width, height, enable_compositor, sync_mode) + } +} + +pub fn destroy_window(window: *mut Window) { + unsafe { + com_wl_destroy_window(window); + } +} + +pub fn tick(window: *mut Window) -> bool { + unsafe { + com_wl_tick(window) + } +} + +pub fn get_proc_address(name: *const c_char) -> *const c_void { + unsafe { + com_wl_get_proc_address(name) + } +} + +pub fn create_surface( + window: *mut Window, + id: u64, + tile_width: i32, + tile_height: i32, + is_opaque: bool, +) { + unsafe { + com_wl_create_surface( + window, + id, + tile_width, + tile_height, + is_opaque, + ) + } +} + +pub fn create_tile( + window: *mut Window, + id: u64, + x: i32, + y: i32, +) { + unsafe { + com_wl_create_tile( + window, + id, + x, + y, + ) + } +} + +pub fn destroy_tile( + window: *mut Window, + id: u64, + x: i32, + y: i32, +) { + unsafe { + com_wl_destroy_tile( + window, + id, + x, + y, + ) + } +} + +pub fn destroy_surface( + window: *mut Window, + id: u64, +) { + unsafe { + com_wl_destroy_surface( + window, + id, + ) + } +} + +pub fn bind_surface( + window: *mut Window, + surface_id: u64, + tile_x: i32, + tile_y: i32, + dirty_x0: i32, + dirty_y0: i32, + dirty_width: i32, + dirty_height: i32, +) -> (u32, i32, i32) { + unsafe { + let mut x_offset = 0; + let mut y_offset = 0; + + let fbo_id = com_wl_bind_surface( + window, + surface_id, + tile_x, + tile_y, + &mut x_offset, + &mut y_offset, + dirty_x0, + dirty_y0, + dirty_width, + dirty_height, + ); + + (fbo_id, x_offset, y_offset) + } +} + +pub fn add_surface( + window: *mut Window, + id: u64, + x: i32, + y: i32, + clip_x: i32, + clip_y: i32, + clip_w: i32, + clip_h: i32, +) { + unsafe { + com_wl_add_surface( + window, + id, + x, + y, + clip_x, + clip_y, + clip_w, + clip_h, + ) + } +} + +pub fn begin_transaction(window: *mut Window) { + unsafe { + com_wl_begin_transaction(window) + } +} + +pub fn unbind_surface(window: *mut Window) { + unsafe { + com_wl_unbind_surface(window) + } +} + +pub fn end_transaction(window: *mut Window) { + unsafe { + com_wl_end_transaction(window) + } +} + +pub fn swap_buffers(window: *mut Window) { + unsafe { + com_wl_swap_buffers(window); + } +} + +pub fn deinit(window: *mut Window) { + unsafe { + com_wl_deinit(window); + } +} |