Initial

.gitignore

@@ -0,0 +1,3 @@
+build/
+.ninja_deps
+.ninja_log

build.ninja

@@ -0,0 +1,32 @@
+libs = -lwayland-client -lwayland-egl -lEGL -lGL -lGLEW -ggdb -lxkbcommon
+cflags = -ggdb
+
+rule cc-bin
+  description = CC $out
+  command = gcc -Ibuild $libs $cflags $in -o $out
+
+rule protocol-header
+  description = PROTO-H $out
+  command = wayland-scanner client-header $in $out
+
+rule protocol-code
+  description = PROTO-C $out
+  command = wayland-scanner private-code $in $out
+
+rule gen-shaders
+  description = SHADERS $in
+  command = ./gen-shaders.sh
+
+build build/doomer : cc-bin main.c build/wlr-layer-shell-unstable-v1.c build/wlr-screencopy-unstable-v1.c build/xdg-shell.c | build/wlr-layer-shell-unstable-v1.h build/wlr-screencopy-unstable-v1.h build/shaders.h
+
+build build/shaders.h : gen-shaders shaders/vertex.glsl shaders/fragment.glsl
+
+build build/wlr-layer-shell-unstable-v1.c : protocol-code protocols/wlr-layer-shell-unstable-v1.xml
+build build/wlr-layer-shell-unstable-v1.h : protocol-header protocols/wlr-layer-shell-unstable-v1.xml
+
+build build/wlr-screencopy-unstable-v1.c : protocol-code protocols/wlr-screencopy-unstable-v1.xml
+build build/wlr-screencopy-unstable-v1.h : protocol-header protocols/wlr-screencopy-unstable-v1.xml
+
+build build/xdg-shell.c : protocol-code protocols/xdg-shell.xml
+
+default build/doomer

gen-shaders.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env sh
+
+echo "" > build/shaders.h
+echo "const char* vertexShaderSource = " >> build/shaders.h
+sed 's/.*/"&\\n"/' shaders/vertex.glsl >> build/shaders.h
+echo ";" >> build/shaders.h
+echo "const char* fragmentShaderSource = " >> build/shaders.h
+sed 's/.*/"&\\n"/' shaders/fragment.glsl >> build/shaders.h
+echo ";" >> build/shaders.h

main.c

@@ -0,0 +1,451 @@
+#define _GNU_SOURCE
+#include <EGL/egl.h>
+#include <GL/glew.h>
+
+#include <GL/gl.h>
+#include <assert.h>
+#include <linux/input-event-codes.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <wayland-client-protocol.h>
+#include <wayland-client.h>
+#include <wayland-egl-core.h>
+#include <wayland-egl.h>
+#include <wayland-util.h>
+#include <xkbcommon/xkbcommon-keysyms.h>
+#include <xkbcommon/xkbcommon-names.h>
+#include <xkbcommon/xkbcommon.h>
+
+#include "wlr-layer-shell-unstable-v1.h"
+#include "wlr-screencopy-unstable-v1.h"
+
+#include "shaders.h"
+
+static struct wl_display *display;
+static EGLDisplay *eglDisplay;
+static struct wl_compositor *compositor;
+static struct wl_shm *shm;
+static struct zwlr_layer_shell_v1 *layerShell;
+static struct zwlr_screencopy_manager_v1 *scManager;
+static struct wl_seat *seat;
+static struct wl_pointer *pointer;
+static struct wl_keyboard *keyboard;
+static struct wl_output *output;
+
+static struct xkb_context *xkb;
+static struct xkb_keymap *keymap;
+static struct xkb_state *xkbState;
+
+static int pointerX, pointerY;
+static bool dragging = false;
+static int dragStartX = 0;
+static int dragStartY = 0;
+
+bool running = true;
+static struct wl_surface *surface;
+static struct zwlr_layer_surface_v1 *layerSurface;
+static struct wl_egl_window *eglWindow;
+static EGLSurface eglSurface;
+static EGLContext eglContext;
+
+static GLuint vertexShader, fragmentShader, shaderProgram;
+static GLuint vao;
+static GLuint texture;
+
+static struct {
+  int width, height, stride;
+  uint8_t *data;
+  bool ready;
+} screenshot;
+
+static struct {
+  float zoom;
+  float x, y;
+} camera;
+float flashlightRadius = 50.0f;
+bool flashlightEnabled = false;
+bool gridEnabled = false;
+
+void noop() {}
+
+void registry_add(void *data, struct wl_registry *registry, uint32_t name,
+                  const char *interface, uint32_t version) {
+  if (!strcmp(interface, "wl_compositor")) {
+    compositor = wl_registry_bind(registry, name, &wl_compositor_interface, 1);
+  } else if (!strcmp(interface, "zwlr_layer_shell_v1")) {
+    layerShell =
+        wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, 1);
+  } else if (!strcmp(interface, "wl_seat")) {
+    seat = wl_registry_bind(registry, name, &wl_seat_interface, 1);
+  } else if (!strcmp(interface, "zwlr_screencopy_manager_v1")) {
+    scManager = wl_registry_bind(registry, name,
+                                 &zwlr_screencopy_manager_v1_interface, 1);
+  } else if (!strcmp(interface, "wl_output")) {
+    output = wl_registry_bind(registry, name, &wl_output_interface, 1);
+  } else if (!strcmp(interface, "wl_shm")) {
+    shm = wl_registry_bind(registry, name, &wl_shm_interface, 1);
+  }
+}
+
+static struct wl_registry_listener registry_listener = {.global = &registry_add,
+                                                        .global_remove = &noop};
+
+void layer_surface_configure(void *data, struct zwlr_layer_surface_v1 *surface,
+                             uint32_t serial, uint32_t width, uint32_t height) {
+  printf("Layer surface configure: %d %d\n", width, height);
+  zwlr_layer_surface_v1_ack_configure(surface, serial);
+  wl_egl_window_resize(eglWindow, width, height, 0, 0);
+};
+
+static struct zwlr_layer_surface_v1_listener layer_surface_listener = {
+    .configure = &layer_surface_configure, .closed = &noop};
+
+void pointer_motion(void *data, struct wl_pointer *pointer, uint32_t time,
+                    wl_fixed_t surface_x, wl_fixed_t surface_y) {
+  pointerX = wl_fixed_to_int(surface_x);
+  pointerY = wl_fixed_to_int(surface_y);
+
+  if (dragging) {
+    float deltaX = (dragStartX / camera.zoom) - (pointerX / camera.zoom);
+    float deltaY = (dragStartY / camera.zoom) - (pointerY / camera.zoom);
+    dragStartX = pointerX;
+    dragStartY = pointerY;
+
+    camera.x += deltaX;
+    camera.y += deltaY;
+  }
+}
+
+void pointer_axis(void *data, struct wl_pointer *pointer, uint32_t time,
+                  uint32_t axis, wl_fixed_t value) {
+  float scroll = wl_fixed_to_double(value);
+
+  if (xkb_state_mod_name_is_active(xkbState, XKB_MOD_NAME_CTRL,
+                                   XKB_STATE_MODS_EFFECTIVE)) {
+
+    flashlightRadius -= scroll;
+    if (flashlightRadius < 0)
+      flashlightRadius = 0;
+  } else {
+    camera.zoom -= scroll / 150.0f * 8.0f;
+    if (camera.zoom < 1)
+      camera.zoom = 1;
+  }
+}
+
+void pointer_button(void *data, struct wl_pointer *pointer, uint32_t serial,
+                    uint32_t time, uint32_t button, uint32_t state) {
+  if (button == BTN_LEFT) {
+    if (!dragging) {
+      dragStartX = pointerX;
+      dragStartY = pointerY;
+    }
+    dragging = state == WL_POINTER_BUTTON_STATE_PRESSED;
+  }
+}
+
+static struct wl_pointer_listener pointer_listener = {.enter = &noop,
+                                                      .leave = &noop,
+                                                      .motion = &pointer_motion,
+                                                      .button = &pointer_button,
+                                                      .axis = &pointer_axis};
+
+void screencopy_buffer(void *data, struct zwlr_screencopy_frame_v1 *frame,
+                       uint32_t format, uint32_t width, uint32_t height,
+                       uint32_t stride) {
+  size_t size = stride * height;
+
+  int fd = memfd_create("screencopy-shm", 0);
+  ftruncate(fd, size);
+
+  screenshot.data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+  screenshot.width = width;
+  screenshot.height = height;
+
+  struct wl_shm_pool *pool = wl_shm_create_pool(shm, fd, size);
+  struct wl_buffer *buffer = wl_shm_pool_create_buffer(
+      pool, 0, width, height, stride, WL_SHM_FORMAT_XRGB8888);
+
+  zwlr_screencopy_frame_v1_copy(frame, buffer);
+}
+
+void screencopy_ready(void *data, struct zwlr_screencopy_frame_v1 *frame,
+                      uint32_t tv_sec_hi, uint32_t tv_sec_lo,
+                      uint32_t tv_nsec) {
+  printf("Frame done!\n");
+  screenshot.ready = true;
+}
+
+static struct zwlr_screencopy_frame_v1_listener screencopy_listener = {
+    .buffer = &screencopy_buffer,
+    .flags = &noop,
+    .ready = &screencopy_ready,
+    .failed = &noop // TODO: error if failed
+};
+
+void keyboard_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format,
+                     int32_t fd, uint32_t size) {
+  void *buf;
+
+  buf = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
+
+  keymap = xkb_keymap_new_from_string(xkb, buf, XKB_KEYMAP_FORMAT_TEXT_V1,
+                                      XKB_KEYMAP_COMPILE_NO_FLAGS);
+  assert(keymap != NULL);
+
+  xkbState = xkb_state_new(keymap);
+}
+
+void keyboard_key(void *data, struct wl_keyboard *keyboad, uint32_t serial,
+                  uint32_t time, uint32_t key, uint32_t state) {
+  xkb_keycode_t keycode = key + 8;
+  printf("key: %d\n", keycode);
+
+  xkb_keysym_t keysym = xkb_state_key_get_one_sym(xkbState, keycode);
+
+  if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
+    if (keysym == XKB_KEY_Escape || keysym == XKB_KEY_q) {
+      running = false;
+    } else if (keysym == XKB_KEY_f) {
+      flashlightEnabled = !flashlightEnabled;
+    } else if (keysym == XKB_KEY_g) {
+      gridEnabled = !gridEnabled;
+    }
+  }
+}
+
+void keyboard_modifiers(void *data, struct wl_keyboard *keyboard,
+                        uint32_t serial, uint32_t mods_depressed,
+                        uint32_t mods_latched, uint32_t mods_locked,
+                        uint32_t group) {
+  xkb_state_update_mask(xkbState, mods_depressed, mods_latched, mods_locked, 0,
+                        0, group);
+}
+
+static struct wl_keyboard_listener keyboard_listener = {
+    .keymap = &keyboard_keymap,
+    .enter = &noop,
+    .leave = &noop,
+    .key = &keyboard_key,
+    .modifiers = &keyboard_modifiers,
+    .repeat_info = &noop};
+
+void gl_debug_callback(GLenum source, GLenum type, GLuint id, GLenum severity,
+                       GLsizei length, const GLchar *message,
+                       const void *userParam) {
+  fprintf(stderr, "GL: %s\n", message);
+}
+
+void create_window() {
+  eglDisplay = eglGetDisplay(display);
+  eglInitialize(eglDisplay, NULL, NULL);
+  eglBindAPI(EGL_OPENGL_API);
+  EGLint attributes[] = {EGL_RED_SIZE,  8, EGL_GREEN_SIZE, 8,
+                         EGL_BLUE_SIZE, 8, EGL_NONE};
+  EGLConfig config;
+  EGLint num_config;
+  eglChooseConfig(eglDisplay, attributes, &config, 1, &num_config);
+  eglContext = eglCreateContext(eglDisplay, config, EGL_NO_CONTEXT, NULL);
+
+  surface = wl_compositor_create_surface(compositor);
+
+  eglWindow = wl_egl_window_create(surface, 1920, 1080);
+  eglSurface = eglCreateWindowSurface(eglDisplay, config,
+                                      (EGLNativeWindowType)eglWindow, NULL);
+  eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext);
+
+  layerSurface = zwlr_layer_shell_v1_get_layer_surface(
+      layerShell, surface, NULL, ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY, "doomer");
+  zwlr_layer_surface_v1_set_anchor(layerSurface,
+                                   ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
+                                       ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM |
+                                       ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
+                                       ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT);
+  zwlr_layer_surface_v1_set_exclusive_zone(layerSurface, -1);
+  zwlr_layer_surface_v1_set_keyboard_interactivity(
+      layerSurface, ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE);
+  zwlr_layer_surface_v1_add_listener(layerSurface, &layer_surface_listener,
+                                     NULL);
+  wl_surface_commit(surface);
+  wl_display_roundtrip(display);
+
+  GLenum err = glewInit();
+  if (err != GLEW_OK) {
+    fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
+  }
+}
+
+void compile_shader(unsigned int shader, const char *code, int size) {
+  glShaderSource(shader, 1, &code, &size);
+  glCompileShader(shader);
+
+  int success;
+  glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+  if (!success) {
+    char infoLog[512];
+    glGetShaderInfoLog(shader, 512, NULL, infoLog);
+    fprintf(stderr, "Shader compilation error: %s\n", infoLog);
+    exit(1);
+  }
+}
+
+void init_shaders() {
+  vertexShader = glCreateShader(GL_VERTEX_SHADER);
+  fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+
+  compile_shader(vertexShader, vertexShaderSource, strlen(vertexShaderSource));
+  compile_shader(fragmentShader, fragmentShaderSource,
+                 strlen(fragmentShaderSource));
+
+  shaderProgram = glCreateProgram();
+  glAttachShader(shaderProgram, vertexShader);
+  glAttachShader(shaderProgram, fragmentShader);
+  glLinkProgram(shaderProgram);
+
+  int success;
+  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
+  if (!success) {
+    char infoLog[512];
+    glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
+    fprintf(stderr, "Shader linking error: %s\n", infoLog);
+    exit(1);
+  }
+
+  glUseProgram(shaderProgram);
+}
+
+void draw_window() {
+  glClearColor(0, 0, 0, 1);
+  glClear(GL_COLOR_BUFFER_BIT);
+
+  glUseProgram(shaderProgram);
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, texture);
+  glUniform1f(glGetUniformLocation(shaderProgram, "cameraScale"), camera.zoom);
+  glUniform2f(glGetUniformLocation(shaderProgram, "cameraPos"), camera.x,
+              camera.y);
+  glUniform1f(glGetUniformLocation(shaderProgram, "flRadius"),
+              flashlightRadius);
+  glUniform1f(glGetUniformLocation(shaderProgram, "flShadow"),
+              flashlightEnabled ? 0.7 : 0.0);
+  glUniform1i(glGetUniformLocation(shaderProgram, "gridEnabled"), gridEnabled);
+  glUniform2f(glGetUniformLocation(shaderProgram, "windowSize"), 1920, 1080);
+  glUniform2f(glGetUniformLocation(shaderProgram, "screenshotSize"),
+              screenshot.width, screenshot.height);
+  glUniform2f(glGetUniformLocation(shaderProgram, "cursorPos"), pointerX,
+              pointerY);
+  glBindVertexArray(vao);
+  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, NULL);
+  glBindVertexArray(0);
+
+  eglSwapBuffers(eglDisplay, eglSurface);
+}
+
+int main() {
+  camera.zoom = 1.0f;
+
+  xkb = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+  assert(xkb != NULL);
+
+  display = wl_display_connect(NULL);
+  assert(display != NULL);
+
+  struct wl_registry *registry = wl_display_get_registry(display);
+  wl_registry_add_listener(registry, &registry_listener, NULL);
+  wl_display_roundtrip(display);
+
+  pointer = wl_seat_get_pointer(seat);
+  keyboard = wl_seat_get_keyboard(seat);
+  wl_keyboard_add_listener(keyboard, &keyboard_listener, NULL);
+  wl_pointer_add_listener(pointer, &pointer_listener, NULL);
+
+  // Start output capture
+  struct zwlr_screencopy_frame_v1 *screencopyFrame =
+      zwlr_screencopy_manager_v1_capture_output(scManager, 0, output);
+  zwlr_screencopy_frame_v1_add_listener(screencopyFrame, &screencopy_listener,
+                                        NULL);
+
+  create_window();
+  init_shaders();
+
+  // Enable OpenGL debug printing
+  glDebugMessageCallback(gl_debug_callback, NULL);
+  glEnable(GL_DEBUG_OUTPUT);
+
+  // Wait for the screenshot to be ready
+  while (!screenshot.ready) {
+    printf("wait...\n");
+    wl_display_dispatch(display);
+  }
+
+  float w = 1920, h = 1080;
+  // x y z u v
+  GLfloat vertices[] = {
+      w, 0, 0.0, 1.0, 1.0, // Top right
+      w, h, 0.0, 1.0, 0.0, // Bottom right
+      0, h, 0.0, 0.0, 0.0, // Bottom left
+      0, 0, 0.0, 0.0, 1.0  // Top left
+  };
+  GLuint indices[] = {0, 1, 3, 1, 2, 3};
+
+  GLuint vbo, ebo;
+  glGenVertexArrays(1, &vao);
+  glGenBuffers(1, &vbo);
+  glGenBuffers(1, &ebo);
+
+  glBindVertexArray(vao);
+  // VBO for vertices
+  glBindBuffer(GL_ARRAY_BUFFER, vbo);
+  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+  // EBO for indices
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices,
+               GL_STATIC_DRAW);
+
+  // x y z u v
+  GLsizei stride = 5 * sizeof(GLfloat);
+
+  // Position
+  glVertexAttribPointer(0, 3, GL_FLOAT, false, stride, NULL);
+  glEnableVertexAttribArray(0);
+
+  // UV
+  glVertexAttribPointer(1, 2, GL_FLOAT, false, stride,
+                        (const void *)(3 * sizeof(GLfloat)));
+  glEnableVertexAttribArray(1);
+
+  glEnable(GL_TEXTURE_2D);
+
+  // Convert texture from XRGB to RGB
+  uint8_t converted[screenshot.width * screenshot.height * 3];
+  for (size_t i = 0; i < (screenshot.width * screenshot.height); i++) {
+    converted[3 * i + 0] = screenshot.data[4 * i + 2];
+    converted[3 * i + 1] = screenshot.data[4 * i + 1];
+    converted[3 * i + 2] = screenshot.data[4 * i + 0];
+  }
+
+  // Create the texture
+  glGenTextures(1, &texture);
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, texture);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screenshot.width, screenshot.height, 0,
+               GL_RGB, GL_UNSIGNED_BYTE, converted);
+  glGenerateMipmap(GL_TEXTURE_2D);
+
+  glBindTexture(GL_TEXTURE_2D, texture);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+
+  while (running) {
+    wl_display_dispatch_pending(display);
+    draw_window();
+  }
+}

protocols/wlr-layer-shell-unstable-v1.xml

@@ -0,0 +1,407 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_layer_shell_unstable_v1">
+  <copyright>
+    Copyright © 2017 Drew DeVault
+
+    Permission to use, copy, modify, distribute, and sell this
+    software and its documentation for any purpose is hereby granted
+    without fee, provided that the above copyright notice appear in
+    all copies and that both that copyright notice and this permission
+    notice appear in supporting documentation, and that the name of
+    the copyright holders not be used in advertising or publicity
+    pertaining to distribution of the software without specific,
+    written prior permission.  The copyright holders make no
+    representations about the suitability of this software for any
+    purpose.  It is provided "as is" without express or implied
+    warranty.
+
+    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+    THIS SOFTWARE.
+  </copyright>
+
+  <interface name="zwlr_layer_shell_v1" version="5">
+    <description summary="create surfaces that are layers of the desktop">
+      Clients can use this interface to assign the surface_layer role to
+      wl_surfaces. Such surfaces are assigned to a "layer" of the output and
+      rendered with a defined z-depth respective to each other. They may also be
+      anchored to the edges and corners of a screen and specify input handling
+      semantics. This interface should be suitable for the implementation of
+      many desktop shell components, and a broad number of other applications
+      that interact with the desktop.
+    </description>
+
+    <request name="get_layer_surface">
+      <description summary="create a layer_surface from a surface">
+        Create a layer surface for an existing surface. This assigns the role of
+        layer_surface, or raises a protocol error if another role is already
+        assigned.
+
+        Creating a layer surface from a wl_surface which has a buffer attached
+        or committed is a client error, and any attempts by a client to attach
+        or manipulate a buffer prior to the first layer_surface.configure call
+        must also be treated as errors.
+
+        After creating a layer_surface object and setting it up, the client
+        must perform an initial commit without any buffer attached.
+        The compositor will reply with a layer_surface.configure event.
+        The client must acknowledge it and is then allowed to attach a buffer
+        to map the surface.
+
+        You may pass NULL for output to allow the compositor to decide which
+        output to use. Generally this will be the one that the user most
+        recently interacted with.
+
+        Clients can specify a namespace that defines the purpose of the layer
+        surface.
+      </description>
+      <arg name="id" type="new_id" interface="zwlr_layer_surface_v1"/>
+      <arg name="surface" type="object" interface="wl_surface"/>
+      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
+      <arg name="layer" type="uint" enum="layer" summary="layer to add this surface to"/>
+      <arg name="namespace" type="string" summary="namespace for the layer surface"/>
+    </request>
+
+    <enum name="error">
+      <entry name="role" value="0" summary="wl_surface has another role"/>
+      <entry name="invalid_layer" value="1" summary="layer value is invalid"/>
+      <entry name="already_constructed" value="2" summary="wl_surface has a buffer attached or committed"/>
+    </enum>
+
+    <enum name="layer">
+      <description summary="available layers for surfaces">
+        These values indicate which layers a surface can be rendered in. They
+        are ordered by z depth, bottom-most first. Traditional shell surfaces
+        will typically be rendered between the bottom and top layers.
+        Fullscreen shell surfaces are typically rendered at the top layer.
+        Multiple surfaces can share a single layer, and ordering within a
+        single layer is undefined.
+      </description>
+
+      <entry name="background" value="0"/>
+      <entry name="bottom" value="1"/>
+      <entry name="top" value="2"/>
+      <entry name="overlay" value="3"/>
+    </enum>
+
+    <!-- Version 3 additions -->
+
+    <request name="destroy" type="destructor" since="3">
+      <description summary="destroy the layer_shell object">
+        This request indicates that the client will not use the layer_shell
+        object any more. Objects that have been created through this instance
+        are not affected.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zwlr_layer_surface_v1" version="5">
+    <description summary="layer metadata interface">
+      An interface that may be implemented by a wl_surface, for surfaces that
+      are designed to be rendered as a layer of a stacked desktop-like
+      environment.
+
+      Layer surface state (layer, size, anchor, exclusive zone,
+      margin, interactivity) is double-buffered, and will be applied at the
+      time wl_surface.commit of the corresponding wl_surface is called.
+
+      Attaching a null buffer to a layer surface unmaps it.
+
+      Unmapping a layer_surface means that the surface cannot be shown by the
+      compositor until it is explicitly mapped again. The layer_surface
+      returns to the state it had right after layer_shell.get_layer_surface.
+      The client can re-map the surface by performing a commit without any
+      buffer attached, waiting for a configure event and handling it as usual.
+    </description>
+
+    <request name="set_size">
+      <description summary="sets the size of the surface">
+        Sets the size of the surface in surface-local coordinates. The
+        compositor will display the surface centered with respect to its
+        anchors.
+
+        If you pass 0 for either value, the compositor will assign it and
+        inform you of the assignment in the configure event. You must set your
+        anchor to opposite edges in the dimensions you omit; not doing so is a
+        protocol error. Both values are 0 by default.
+
+        Size is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="width" type="uint"/>
+      <arg name="height" type="uint"/>
+    </request>
+
+    <request name="set_anchor">
+      <description summary="configures the anchor point of the surface">
+        Requests that the compositor anchor the surface to the specified edges
+        and corners. If two orthogonal edges are specified (e.g. 'top' and
+        'left'), then the anchor point will be the intersection of the edges
+        (e.g. the top left corner of the output); otherwise the anchor point
+        will be centered on that edge, or in the center if none is specified.
+
+        Anchor is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="anchor" type="uint" enum="anchor"/>
+    </request>
+
+    <request name="set_exclusive_zone">
+      <description summary="configures the exclusive geometry of this surface">
+        Requests that the compositor avoids occluding an area with other
+        surfaces. The compositor's use of this information is
+        implementation-dependent - do not assume that this region will not
+        actually be occluded.
+
+        A positive value is only meaningful if the surface is anchored to one
+        edge or an edge and both perpendicular edges. If the surface is not
+        anchored, anchored to only two perpendicular edges (a corner), anchored
+        to only two parallel edges or anchored to all edges, a positive value
+        will be treated the same as zero.
+
+        A positive zone is the distance from the edge in surface-local
+        coordinates to consider exclusive.
+
+        Surfaces that do not wish to have an exclusive zone may instead specify
+        how they should interact with surfaces that do. If set to zero, the
+        surface indicates that it would like to be moved to avoid occluding
+        surfaces with a positive exclusive zone. If set to -1, the surface
+        indicates that it would not like to be moved to accommodate for other
+        surfaces, and the compositor should extend it all the way to the edges
+        it is anchored to.
+
+        For example, a panel might set its exclusive zone to 10, so that
+        maximized shell surfaces are not shown on top of it. A notification
+        might set its exclusive zone to 0, so that it is moved to avoid
+        occluding the panel, but shell surfaces are shown underneath it. A
+        wallpaper or lock screen might set their exclusive zone to -1, so that
+        they stretch below or over the panel.
+
+        The default value is 0.
+
+        Exclusive zone is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="zone" type="int"/>
+    </request>
+
+    <request name="set_margin">
+      <description summary="sets a margin from the anchor point">
+        Requests that the surface be placed some distance away from the anchor
+        point on the output, in surface-local coordinates. Setting this value
+        for edges you are not anchored to has no effect.
+
+        The exclusive zone includes the margin.
+
+        Margin is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="top" type="int"/>
+      <arg name="right" type="int"/>
+      <arg name="bottom" type="int"/>
+      <arg name="left" type="int"/>
+    </request>
+
+    <enum name="keyboard_interactivity">
+      <description summary="types of keyboard interaction possible for a layer shell surface">
+        Types of keyboard interaction possible for layer shell surfaces. The
+        rationale for this is twofold: (1) some applications are not interested
+        in keyboard events and not allowing them to be focused can improve the
+        desktop experience; (2) some applications will want to take exclusive
+        keyboard focus.
+      </description>
+
+      <entry name="none" value="0">
+        <description summary="no keyboard focus is possible">
+          This value indicates that this surface is not interested in keyboard
+          events and the compositor should never assign it the keyboard focus.
+
+          This is the default value, set for newly created layer shell surfaces.
+
+          This is useful for e.g. desktop widgets that display information or
+          only have interaction with non-keyboard input devices.
+        </description>
+      </entry>
+      <entry name="exclusive" value="1">
+        <description summary="request exclusive keyboard focus">
+          Request exclusive keyboard focus if this surface is above the shell surface layer.
+
+          For the top and overlay layers, the seat will always give
+          exclusive keyboard focus to the top-most layer which has keyboard
+          interactivity set to exclusive. If this layer contains multiple
+          surfaces with keyboard interactivity set to exclusive, the compositor
+          determines the one receiving keyboard events in an implementation-
+          defined manner. In this case, no guarantee is made when this surface
+          will receive keyboard focus (if ever).
+
+          For the bottom and background layers, the compositor is allowed to use
+          normal focus semantics.
+
+          This setting is mainly intended for applications that need to ensure
+          they receive all keyboard events, such as a lock screen or a password
+          prompt.
+        </description>
+      </entry>
+      <entry name="on_demand" value="2" since="4">
+        <description summary="request regular keyboard focus semantics">
+          This requests the compositor to allow this surface to be focused and
+          unfocused by the user in an implementation-defined manner. The user
+          should be able to unfocus this surface even regardless of the layer
+          it is on.
+
+          Typically, the compositor will want to use its normal mechanism to
+          manage keyboard focus between layer shell surfaces with this setting
+          and regular toplevels on the desktop layer (e.g. click to focus).
+          Nevertheless, it is possible for a compositor to require a special
+          interaction to focus or unfocus layer shell surfaces (e.g. requiring
+          a click even if focus follows the mouse normally, or providing a
+          keybinding to switch focus between layers).
+
+          This setting is mainly intended for desktop shell components (e.g.
+          panels) that allow keyboard interaction. Using this option can allow
+          implementing a desktop shell that can be fully usable without the
+          mouse.
+        </description>
+      </entry>
+    </enum>
+
+    <request name="set_keyboard_interactivity">
+      <description summary="requests keyboard events">
+        Set how keyboard events are delivered to this surface. By default,
+        layer shell surfaces do not receive keyboard events; this request can
+        be used to change this.
+
+        This setting is inherited by child surfaces set by the get_popup
+        request.
+
+        Layer surfaces receive pointer, touch, and tablet events normally. If
+        you do not want to receive them, set the input region on your surface
+        to an empty region.
+
+        Keyboard interactivity is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="keyboard_interactivity" type="uint" enum="keyboard_interactivity"/>
+    </request>
+
+    <request name="get_popup">
+      <description summary="assign this layer_surface as an xdg_popup parent">
+        This assigns an xdg_popup's parent to this layer_surface.  This popup
+        should have been created via xdg_surface::get_popup with the parent set
+        to NULL, and this request must be invoked before committing the popup's
+        initial state.
+
+        See the documentation of xdg_popup for more details about what an
+        xdg_popup is and how it is used.
+      </description>
+      <arg name="popup" type="object" interface="xdg_popup"/>
+    </request>
+
+    <request name="ack_configure">
+      <description summary="ack a configure event">
+        When a configure event is received, if a client commits the
+        surface in response to the configure event, then the client
+        must make an ack_configure request sometime before the commit
+        request, passing along the serial of the configure event.
+
+        If the client receives multiple configure events before it
+        can respond to one, it only has to ack the last configure event.
+
+        A client is not required to commit immediately after sending
+        an ack_configure request - it may even ack_configure several times
+        before its next surface commit.
+
+        A client may send multiple ack_configure requests before committing, but
+        only the last request sent before a commit indicates which configure
+        event the client really is responding to.
+      </description>
+      <arg name="serial" type="uint" summary="the serial from the configure event"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the layer_surface">
+        This request destroys the layer surface.
+      </description>
+    </request>
+
+    <event name="configure">
+      <description summary="suggest a surface change">
+        The configure event asks the client to resize its surface.
+
+        Clients should arrange their surface for the new states, and then send
+        an ack_configure request with the serial sent in this configure event at
+        some point before committing the new surface.
+
+        The client is free to dismiss all but the last configure event it
+        received.
+
+        The width and height arguments specify the size of the window in
+        surface-local coordinates.
+
+        The size is a hint, in the sense that the client is free to ignore it if
+        it doesn't resize, pick a smaller size (to satisfy aspect ratio or
+        resize in steps of NxM pixels). If the client picks a smaller size and
+        is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the
+        surface will be centered on this axis.
+
+        If the width or height arguments are zero, it means the client should
+        decide its own window dimension.
+      </description>
+      <arg name="serial" type="uint"/>
+      <arg name="width" type="uint"/>
+      <arg name="height" type="uint"/>
+    </event>
+
+    <event name="closed">
+      <description summary="surface should be closed">
+        The closed event is sent by the compositor when the surface will no
+        longer be shown. The output may have been destroyed or the user may
+        have asked for it to be removed. Further changes to the surface will be
+        ignored. The client should destroy the resource after receiving this
+        event, and create a new surface if they so choose.
+      </description>
+    </event>
+
+    <enum name="error">
+      <entry name="invalid_surface_state" value="0" summary="provided surface state is invalid"/>
+      <entry name="invalid_size" value="1" summary="size is invalid"/>
+      <entry name="invalid_anchor" value="2" summary="anchor bitfield is invalid"/>
+      <entry name="invalid_keyboard_interactivity" value="3" summary="keyboard interactivity is invalid"/>
+      <entry name="invalid_exclusive_edge" value="4" summary="exclusive edge is invalid given the surface anchors"/>
+    </enum>
+
+    <enum name="anchor" bitfield="true">
+      <entry name="top" value="1" summary="the top edge of the anchor rectangle"/>
+      <entry name="bottom" value="2" summary="the bottom edge of the anchor rectangle"/>
+      <entry name="left" value="4" summary="the left edge of the anchor rectangle"/>
+      <entry name="right" value="8" summary="the right edge of the anchor rectangle"/>
+    </enum>
+
+    <!-- Version 2 additions -->
+
+    <request name="set_layer" since="2">
+      <description summary="change the layer of the surface">
+        Change the layer that the surface is rendered on.
+
+        Layer is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="layer" type="uint" enum="zwlr_layer_shell_v1.layer" summary="layer to move this surface to"/>
+    </request>
+
+    <!-- Version 5 additions -->
+
+    <request name="set_exclusive_edge" since="5">
+      <description summary="set the edge the exclusive zone will be applied to">
+        Requests an edge for the exclusive zone to apply. The exclusive
+        edge will be automatically deduced from anchor points when possible,
+        but when the surface is anchored to a corner, it will be necessary
+        to set it explicitly to disambiguate, as it is not possible to deduce
+        which one of the two corner edges should be used.
+
+        The edge must be one the surface is anchored to, otherwise the
+        invalid_exclusive_edge protocol error will be raised.
+      </description>
+      <arg name="edge" type="uint" enum="anchor"/>
+    </request>
+  </interface>
+</protocol>

protocols/wlr-screencopy-unstable-v1.xml

@@ -0,0 +1,231 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_screencopy_unstable_v1">
+  <copyright>
+    Copyright © 2018 Simon Ser
+    Copyright © 2019 Andri Yngvason
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <description summary="screen content capturing on client buffers">
+    This protocol allows clients to ask the compositor to copy part of the
+    screen content to a client buffer.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible changes
+    may be added together with the corresponding interface version bump.
+    Backward incompatible changes are done by bumping the version number in
+    the protocol and interface names and resetting the interface version.
+    Once the protocol is to be declared stable, the 'z' prefix and the
+    version number in the protocol and interface names are removed and the
+    interface version number is reset.
+  </description>
+
+  <interface name="zwlr_screencopy_manager_v1" version="3">
+    <description summary="manager to inform clients and begin capturing">
+      This object is a manager which offers requests to start capturing from a
+      source.
+    </description>
+
+    <request name="capture_output">
+      <description summary="capture an output">
+        Capture the next frame of an entire output.
+      </description>
+      <arg name="frame" type="new_id" interface="zwlr_screencopy_frame_v1"/>
+      <arg name="overlay_cursor" type="int"
+        summary="composite cursor onto the frame"/>
+      <arg name="output" type="object" interface="wl_output"/>
+    </request>
+
+    <request name="capture_output_region">
+      <description summary="capture an output's region">
+        Capture the next frame of an output's region.
+
+        The region is given in output logical coordinates, see
+        xdg_output.logical_size. The region will be clipped to the output's
+        extents.
+      </description>
+      <arg name="frame" type="new_id" interface="zwlr_screencopy_frame_v1"/>
+      <arg name="overlay_cursor" type="int"
+        summary="composite cursor onto the frame"/>
+      <arg name="output" type="object" interface="wl_output"/>
+      <arg name="x" type="int"/>
+      <arg name="y" type="int"/>
+      <arg name="width" type="int"/>
+      <arg name="height" type="int"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the manager">
+        All objects created by the manager will still remain valid, until their
+        appropriate destroy request has been called.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zwlr_screencopy_frame_v1" version="3">
+    <description summary="a frame ready for copy">
+      This object represents a single frame.
+
+      When created, a series of buffer events will be sent, each representing a
+      supported buffer type. The "buffer_done" event is sent afterwards to
+      indicate that all supported buffer types have been enumerated. The client
+      will then be able to send a "copy" request. If the capture is successful,
+      the compositor will send a "flags" event followed by a "ready" event.
+
+      For objects version 2 or lower, wl_shm buffers are always supported, ie.
+      the "buffer" event is guaranteed to be sent.
+
+      If the capture failed, the "failed" event is sent. This can happen anytime
+      before the "ready" event.
+
+      Once either a "ready" or a "failed" event is received, the client should
+      destroy the frame.
+    </description>
+
+    <event name="buffer">
+      <description summary="wl_shm buffer information">
+        Provides information about wl_shm buffer parameters that need to be
+        used for this frame. This event is sent once after the frame is created
+        if wl_shm buffers are supported.
+      </description>
+      <arg name="format" type="uint" enum="wl_shm.format" summary="buffer format"/>
+      <arg name="width" type="uint" summary="buffer width"/>
+      <arg name="height" type="uint" summary="buffer height"/>
+      <arg name="stride" type="uint" summary="buffer stride"/>
+    </event>
+
+    <request name="copy">
+      <description summary="copy the frame">
+        Copy the frame to the supplied buffer. The buffer must have the
+        correct size, see zwlr_screencopy_frame_v1.buffer and
+        zwlr_screencopy_frame_v1.linux_dmabuf. The buffer needs to have a
+        supported format.
+
+        If the frame is successfully copied, "flags" and "ready" events are
+        sent. Otherwise, a "failed" event is sent.
+      </description>
+      <arg name="buffer" type="object" interface="wl_buffer"/>
+    </request>
+
+    <enum name="error">
+      <entry name="already_used" value="0"
+        summary="the object has already been used to copy a wl_buffer"/>
+      <entry name="invalid_buffer" value="1"
+        summary="buffer attributes are invalid"/>
+    </enum>
+
+    <enum name="flags" bitfield="true">
+      <entry name="y_invert" value="1" summary="contents are y-inverted"/>
+    </enum>
+
+    <event name="flags">
+      <description summary="frame flags">
+        Provides flags about the frame. This event is sent once before the
+        "ready" event.
+      </description>
+      <arg name="flags" type="uint" enum="flags" summary="frame flags"/>
+    </event>
+
+    <event name="ready">
+      <description summary="indicates frame is available for reading">
+        Called as soon as the frame is copied, indicating it is available
+        for reading. This event includes the time at which the presentation took place.
+
+        The timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples,
+        each component being an unsigned 32-bit value. Whole seconds are in
+        tv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo,
+        and the additional fractional part in tv_nsec as nanoseconds. Hence,
+        for valid timestamps tv_nsec must be in [0, 999999999]. The seconds part
+        may have an arbitrary offset at start.
+
+        After receiving this event, the client should destroy the object.
+      </description>
+      <arg name="tv_sec_hi" type="uint"
+           summary="high 32 bits of the seconds part of the timestamp"/>
+      <arg name="tv_sec_lo" type="uint"
+           summary="low 32 bits of the seconds part of the timestamp"/>
+      <arg name="tv_nsec" type="uint"
+           summary="nanoseconds part of the timestamp"/>
+    </event>
+
+    <event name="failed">
+      <description summary="frame copy failed">
+        This event indicates that the attempted frame copy has failed.
+
+        After receiving this event, the client should destroy the object.
+      </description>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="delete this object, used or not">
+        Destroys the frame. This request can be sent at any time by the client.
+      </description>
+    </request>
+
+    <!-- Version 2 additions -->
+    <request name="copy_with_damage" since="2">
+      <description summary="copy the frame when it's damaged">
+        Same as copy, except it waits until there is damage to copy.
+      </description>
+      <arg name="buffer" type="object" interface="wl_buffer"/>
+    </request>
+
+    <event name="damage" since="2">
+      <description summary="carries the coordinates of the damaged region">
+        This event is sent right before the ready event when copy_with_damage is
+        requested. It may be generated multiple times for each copy_with_damage
+        request.
+
+        The arguments describe a box around an area that has changed since the
+        last copy request that was derived from the current screencopy manager
+        instance.
+
+        The union of all regions received between the call to copy_with_damage
+        and a ready event is the total damage since the prior ready event.
+      </description>
+      <arg name="x" type="uint" summary="damaged x coordinates"/>
+      <arg name="y" type="uint" summary="damaged y coordinates"/>
+      <arg name="width" type="uint" summary="current width"/>
+      <arg name="height" type="uint" summary="current height"/>
+    </event>
+
+    <!-- Version 3 additions -->
+    <event name="linux_dmabuf" since="3">
+      <description summary="linux-dmabuf buffer information">
+        Provides information about linux-dmabuf buffer parameters that need to
+        be used for this frame. This event is sent once after the frame is
+        created if linux-dmabuf buffers are supported.
+      </description>
+      <arg name="format" type="uint" summary="fourcc pixel format"/>
+      <arg name="width" type="uint" summary="buffer width"/>
+      <arg name="height" type="uint" summary="buffer height"/>
+    </event>
+
+    <event name="buffer_done" since="3">
+      <description summary="all buffer types reported">
+        This event is sent once after all buffer events have been sent.
+
+        The client should proceed to create a buffer of one of the supported
+        types, and send a "copy" request.
+      </description>
+    </event>
+  </interface>
+</protocol>

shaders/fragment.glsl

@@ -0,0 +1,26 @@
+#version 130
+out mediump vec4 color;
+in mediump vec2 texcoord;
+uniform sampler2D tex;
+uniform vec2 cursorPos;
+uniform vec2 windowSize;
+uniform vec2 screenshotSize;
+uniform float flShadow;
+uniform float flRadius;
+uniform float cameraScale;
+uniform bool gridEnabled;
+
+void main()
+{
+    vec4 cursor = vec4(cursorPos.x, windowSize.y - cursorPos.y, 0.0, 1.0);
+    color = mix(
+        texture(tex, texcoord), vec4(0.0, 0.0, 0.0, 0.0),
+        length(cursor - gl_FragCoord) < (flRadius * cameraScale) ? 0.0 : flShadow);
+
+    if(gridEnabled){
+        vec2 uv = texcoord * screenshotSize;
+        if(fract(uv.x) < 0.04f || fract(uv.y) < 0.04f)
+            color = vec4(0.0);
+    }
+
+}

shaders/vertex.glsl

@@ -0,0 +1,25 @@
+#version 130
+in vec3 aPos;
+in vec2 aTexCoord;
+out vec2 texcoord;
+
+uniform vec2 cameraPos;
+uniform float cameraScale;
+uniform vec2 windowSize;
+uniform vec2 screenshotSize;
+uniform vec2 cursorPos;
+
+vec3 to_world(vec3 v) {
+    vec2 ratio = vec2(
+        windowSize.x / screenshotSize.x / cameraScale,
+        windowSize.y / screenshotSize.y / cameraScale);
+    return vec3((v.x / screenshotSize.x * 2.0 - 1.0) / ratio.x,
+                (v.y / screenshotSize.y * 2.0 - 1.0) / ratio.y,
+                v.z);
+}
+
+void main()
+{
+  gl_Position = vec4(to_world((aPos - vec3(cameraPos * vec2(1.0, -1.0), 0.0))), 1.0);
+  texcoord = aTexCoord;
+}