10 files changed, 1003 insertions, 0 deletions

diff --git a/sway/desktop/fx_renderer/fx_renderer.c b/sway/desktop/fx_renderer/fx_renderer.c
new file mode 100644
index 00000000..36c5bb61
--- /dev/null
+++ b/sway/desktop/fx_renderer/fx_renderer.c
@@ -0,0 +1,671 @@
+/*
+	The original wlr_renderer was heavily referenced in making this project
+	https://gitlab.freedesktop.org/wlroots/wlroots/-/tree/master/render/gles2
+*/
+
+#include <assert.h>
+#include <GLES2/gl2.h>
+#include <stdlib.h>
+#include <wlr/backend.h>
+#include <wlr/render/egl.h>
+#include <wlr/render/gles2.h>
+#include <wlr/types/wlr_matrix.h>
+#include <wlr/util/box.h>
+
+#include "log.h"
+#include "sway/desktop/fx_renderer/fx_renderer.h"
+#include "sway/desktop/fx_renderer/matrix.h"
+#include "sway/output.h"
+#include "sway/server.h"
+
+// shaders
+#include "box_shadow_frag_src.h"
+#include "common_vert_src.h"
+#include "corner_frag_src.h"
+#include "quad_frag_src.h"
+#include "quad_round_frag_src.h"
+#include "tex_frag_src.h"
+
+static const GLfloat verts[] = {
+	1, 0, // top right
+	0, 0, // top left
+	1, 1, // bottom right
+	0, 1, // bottom left
+};
+
+static GLuint compile_shader(GLuint type, const GLchar *src) {
+	GLuint shader = glCreateShader(type);
+	glShaderSource(shader, 1, &src, NULL);
+	glCompileShader(shader);
+
+	GLint ok;
+	glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
+	if (ok == GL_FALSE) {
+		sway_log(SWAY_ERROR, "Failed to compile shader");
+		glDeleteShader(shader);
+		shader = 0;
+	}
+
+	return shader;
+}
+
+static GLuint link_program(const GLchar *frag_src) {
+	const GLchar *vert_src = common_vert_src;
+	GLuint vert = compile_shader(GL_VERTEX_SHADER, vert_src);
+	if (!vert) {
+		goto error;
+	}
+
+	GLuint frag = compile_shader(GL_FRAGMENT_SHADER, frag_src);
+	if (!frag) {
+		glDeleteShader(vert);
+		goto error;
+	}
+
+	GLuint prog = glCreateProgram();
+	glAttachShader(prog, vert);
+	glAttachShader(prog, frag);
+	glLinkProgram(prog);
+
+	glDetachShader(prog, vert);
+	glDetachShader(prog, frag);
+	glDeleteShader(vert);
+	glDeleteShader(frag);
+
+	GLint ok;
+	glGetProgramiv(prog, GL_LINK_STATUS, &ok);
+	if (ok == GL_FALSE) {
+		sway_log(SWAY_ERROR, "Failed to link shader");
+		glDeleteProgram(prog);
+		goto error;
+	}
+
+	return prog;
+
+error:
+	return 0;
+}
+
+static bool link_tex_program(struct fx_renderer *renderer,
+		struct gles2_tex_shader *shader, enum fx_tex_shader_source source) {
+	GLchar frag_src[2048];
+	snprintf(frag_src, sizeof(frag_src),
+		"#define SOURCE %d\n%s", source, tex_frag_src);
+
+	GLuint prog;
+	shader->program = prog = link_program(frag_src);
+	if (!shader->program) {
+		return false;
+	}
+
+	shader->proj = glGetUniformLocation(prog, "proj");
+	shader->tex = glGetUniformLocation(prog, "tex");
+	shader->alpha = glGetUniformLocation(prog, "alpha");
+	shader->dim = glGetUniformLocation(prog, "dim");
+	shader->dim_color = glGetUniformLocation(prog, "dim_color");
+	shader->pos_attrib = glGetAttribLocation(prog, "pos");
+	shader->tex_attrib = glGetAttribLocation(prog, "texcoord");
+	shader->size = glGetUniformLocation(prog, "size");
+	shader->position = glGetUniformLocation(prog, "position");
+	shader->radius = glGetUniformLocation(prog, "radius");
+	shader->saturation = glGetUniformLocation(prog, "saturation");
+	shader->has_titlebar = glGetUniformLocation(prog, "has_titlebar");
+
+	return true;
+}
+
+static bool link_rounded_quad_program(struct fx_renderer *renderer,
+		struct rounded_quad_shader *shader, enum fx_rounded_quad_shader_source source) {
+	GLchar quad_src[2048];
+	snprintf(quad_src, sizeof(quad_src),
+		"#define SOURCE %d\n%s", source, quad_round_frag_src);
+
+	GLuint prog;
+	shader->program = prog = link_program(quad_src);
+	if (!shader->program) {
+		return false;
+	}
+
+	shader->proj = glGetUniformLocation(prog, "proj");
+	shader->color = glGetUniformLocation(prog, "color");
+	shader->pos_attrib = glGetAttribLocation(prog, "pos");
+	shader->size = glGetUniformLocation(prog, "size");
+	shader->position = glGetUniformLocation(prog, "position");
+	shader->radius = glGetUniformLocation(prog, "radius");
+
+	return true;
+}
+
+static bool check_gl_ext(const char *exts, const char *ext) {
+	size_t extlen = strlen(ext);
+	const char *end = exts + strlen(exts);
+
+	while (exts < end) {
+		if (exts[0] == ' ') {
+			exts++;
+			continue;
+		}
+		size_t n = strcspn(exts, " ");
+		if (n == extlen && strncmp(ext, exts, n) == 0) {
+			return true;
+		}
+		exts += n;
+	}
+	return false;
+}
+
+static void load_gl_proc(void *proc_ptr, const char *name) {
+	void *proc = (void *)eglGetProcAddress(name);
+	if (proc == NULL) {
+		sway_log(SWAY_ERROR, "GLES2 RENDERER: eglGetProcAddress(%s) failed", name);
+		abort();
+	}
+	*(void **)proc_ptr = proc;
+}
+
+struct fx_renderer *fx_renderer_create(struct wlr_egl *egl) {
+	struct fx_renderer *renderer = calloc(1, sizeof(struct fx_renderer));
+	if (renderer == NULL) {
+		return NULL;
+	}
+
+	// TODO: wlr_egl_make_current or eglMakeCurrent?
+	// TODO: assert instead of conditional statement?
+	if (!eglMakeCurrent(wlr_egl_get_display(egl), EGL_NO_SURFACE, EGL_NO_SURFACE,
+			wlr_egl_get_context(egl))) {
+		sway_log(SWAY_ERROR, "GLES2 RENDERER: Could not make EGL current");
+		return NULL;
+	}
+	// TODO: needed?
+	renderer->egl = egl;
+
+	// get extensions
+	const char *exts_str = (const char *)glGetString(GL_EXTENSIONS);
+	if (exts_str == NULL) {
+		sway_log(SWAY_ERROR, "GLES2 RENDERER: Failed to get GL_EXTENSIONS");
+		return NULL;
+	}
+
+	sway_log(SWAY_INFO, "Creating swayfx GLES2 renderer");
+	sway_log(SWAY_INFO, "Using %s", glGetString(GL_VERSION));
+	sway_log(SWAY_INFO, "GL vendor: %s", glGetString(GL_VENDOR));
+	sway_log(SWAY_INFO, "GL renderer: %s", glGetString(GL_RENDERER));
+	sway_log(SWAY_INFO, "Supported GLES2 extensions: %s", exts_str);
+
+	// TODO: the rest of the gl checks
+	if (check_gl_ext(exts_str, "GL_OES_EGL_image_external")) {
+		renderer->exts.OES_egl_image_external = true;
+		load_gl_proc(&renderer->procs.glEGLImageTargetTexture2DOES,
+			"glEGLImageTargetTexture2DOES");
+	}
+
+	// init shaders
+	GLuint prog;
+
+	// quad fragment shader
+	prog = link_program(quad_frag_src);
+	renderer->shaders.quad.program = prog;
+	if (!renderer->shaders.quad.program) {
+		goto error;
+	}
+	renderer->shaders.quad.proj = glGetUniformLocation(prog, "proj");
+	renderer->shaders.quad.color = glGetUniformLocation(prog, "color");
+	renderer->shaders.quad.pos_attrib = glGetAttribLocation(prog, "pos");
+
+	// rounded quad fragment shaders
+	if (!link_rounded_quad_program(renderer, &renderer->shaders.rounded_quad,
+			SHADER_SOURCE_QUAD_ROUND)) {
+		goto error;
+	}
+	if (!link_rounded_quad_program(renderer, &renderer->shaders.rounded_tl_quad,
+			SHADER_SOURCE_QUAD_ROUND_TOP_LEFT)) {
+		goto error;
+	}
+	if (!link_rounded_quad_program(renderer, &renderer->shaders.rounded_tr_quad,
+			SHADER_SOURCE_QUAD_ROUND_TOP_RIGHT)) {
+		goto error;
+	}
+
+	// Border corner shader
+	prog = link_program(corner_frag_src);
+	renderer->shaders.corner.program = prog;
+	if (!renderer->shaders.corner.program) {
+		goto error;
+	}
+	renderer->shaders.corner.proj = glGetUniformLocation(prog, "proj");
+	renderer->shaders.corner.color = glGetUniformLocation(prog, "color");
+	renderer->shaders.corner.pos_attrib = glGetAttribLocation(prog, "pos");
+	renderer->shaders.corner.is_top_left = glGetUniformLocation(prog, "is_top_left");
+	renderer->shaders.corner.is_top_right = glGetUniformLocation(prog, "is_top_right");
+	renderer->shaders.corner.is_bottom_left = glGetUniformLocation(prog, "is_bottom_left");
+	renderer->shaders.corner.is_bottom_right = glGetUniformLocation(prog, "is_bottom_right");
+	renderer->shaders.corner.position = glGetUniformLocation(prog, "position");
+	renderer->shaders.corner.radius = glGetUniformLocation(prog, "radius");
+	renderer->shaders.corner.half_size = glGetUniformLocation(prog, "half_size");
+	renderer->shaders.corner.half_thickness = glGetUniformLocation(prog, "half_thickness");
+
+	// box shadow shader
+	prog = link_program(box_shadow_frag_src);
+	renderer->shaders.box_shadow.program = prog;
+	if (!renderer->shaders.box_shadow.program) {
+		goto error;
+	}
+	renderer->shaders.box_shadow.proj = glGetUniformLocation(prog, "proj");
+	renderer->shaders.box_shadow.color = glGetUniformLocation(prog, "color");
+	renderer->shaders.box_shadow.pos_attrib = glGetAttribLocation(prog, "pos");
+	renderer->shaders.box_shadow.position = glGetUniformLocation(prog, "position");
+	renderer->shaders.box_shadow.size = glGetUniformLocation(prog, "size");
+	renderer->shaders.box_shadow.blur_sigma = glGetUniformLocation(prog, "blur_sigma");
+	renderer->shaders.box_shadow.corner_radius = glGetUniformLocation(prog, "corner_radius");
+
+	// fragment shaders
+	if (!link_tex_program(renderer, &renderer->shaders.tex_rgba,
+			SHADER_SOURCE_TEXTURE_RGBA)) {
+		goto error;
+	}
+	if (!link_tex_program(renderer, &renderer->shaders.tex_rgbx,
+			SHADER_SOURCE_TEXTURE_RGBX)) {
+		goto error;
+	}
+	if (!link_tex_program(renderer, &renderer->shaders.tex_ext,
+			SHADER_SOURCE_TEXTURE_EXTERNAL)) {
+		goto error;
+	}
+
+
+	if (!eglMakeCurrent(wlr_egl_get_display(renderer->egl),
+				EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)) {
+		sway_log(SWAY_ERROR, "GLES2 RENDERER: Could not unset current EGL");
+		goto error;
+	}
+
+	sway_log(SWAY_INFO, "GLES2 RENDERER: Shaders Initialized Successfully");
+	return renderer;
+
+error:
+	glDeleteProgram(renderer->shaders.quad.program);
+	glDeleteProgram(renderer->shaders.rounded_quad.program);
+	glDeleteProgram(renderer->shaders.rounded_tl_quad.program);
+	glDeleteProgram(renderer->shaders.rounded_tr_quad.program);
+	glDeleteProgram(renderer->shaders.corner.program);
+	glDeleteProgram(renderer->shaders.box_shadow.program);
+	glDeleteProgram(renderer->shaders.tex_rgba.program);
+	glDeleteProgram(renderer->shaders.tex_rgbx.program);
+	glDeleteProgram(renderer->shaders.tex_ext.program);
+
+	if (!eglMakeCurrent(wlr_egl_get_display(renderer->egl),
+				EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)) {
+		sway_log(SWAY_ERROR, "GLES2 RENDERER: Could not unset current EGL");
+	}
+
+	// TODO: more freeing?
+	free(renderer);
+
+	sway_log(SWAY_ERROR, "GLES2 RENDERER: Error Initializing Shaders");
+	return NULL;
+}
+
+void fx_renderer_begin(struct fx_renderer *renderer, uint32_t width, uint32_t height) {
+	// Create and render the stencil buffer
+	if (renderer->stencil_buffer_id == 0) {
+		glGenRenderbuffers(1, &renderer->stencil_buffer_id);
+	}
+	glBindRenderbuffer(GL_RENDERBUFFER, renderer->stencil_buffer_id);
+	glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, width, height);
+	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
+			GL_RENDERBUFFER, renderer->stencil_buffer_id);
+
+	glViewport(0, 0, width, height);
+
+	// refresh projection matrix
+	matrix_projection(renderer->projection, width, height,
+		WL_OUTPUT_TRANSFORM_FLIPPED_180);
+
+	glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+}
+
+void fx_renderer_end() {
+	// TODO
+}
+
+void fx_renderer_clear(const float color[static 4]) {
+	glClearColor(color[0], color[1], color[2], color[3]);
+	glClearStencil(0);
+	glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+}
+
+void fx_renderer_scissor(struct wlr_box *box) {
+		if (box) {
+				glScissor(box->x, box->y, box->width, box->height);
+				glEnable(GL_SCISSOR_TEST);
+		} else {
+				glDisable(GL_SCISSOR_TEST);
+		}
+}
+
+bool fx_render_subtexture_with_matrix(struct fx_renderer *renderer, struct wlr_texture *wlr_texture,
+		const struct wlr_fbox *src_box, const struct wlr_box *dst_box, const float matrix[static 9],
+		struct decoration_data deco_data) {
+	assert(wlr_texture_is_gles2(wlr_texture));
+	struct wlr_gles2_texture_attribs texture_attrs;
+	wlr_gles2_texture_get_attribs(wlr_texture, &texture_attrs);
+
+	struct gles2_tex_shader *shader = NULL;
+
+	switch (texture_attrs.target) {
+	case GL_TEXTURE_2D:
+		if (texture_attrs.has_alpha) {
+			shader = &renderer->shaders.tex_rgba;
+		} else {
+			shader = &renderer->shaders.tex_rgbx;
+		}
+		break;
+	case GL_TEXTURE_EXTERNAL_OES:
+		shader = &renderer->shaders.tex_ext;
+
+		if (!renderer->exts.OES_egl_image_external) {
+			sway_log(SWAY_ERROR, "Failed to render texture: "
+				"GL_TEXTURE_EXTERNAL_OES not supported");
+			return false;
+		}
+		break;
+	default:
+		sway_log(SWAY_ERROR, "Aborting render");
+		abort();
+	}
+
+	float gl_matrix[9];
+	wlr_matrix_multiply(gl_matrix, renderer->projection, matrix);
+
+	// OpenGL ES 2 requires the glUniformMatrix3fv transpose parameter to be set
+	// to GL_FALSE
+	wlr_matrix_transpose(gl_matrix, gl_matrix);
+
+	// if there's no opacity or rounded corners we don't need to blend
+	if (!texture_attrs.has_alpha && deco_data.alpha == 1.0 && !deco_data.corner_radius) {
+		glDisable(GL_BLEND);
+	} else {
+		glEnable(GL_BLEND);
+	}
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(texture_attrs.target, texture_attrs.tex);
+
+	glTexParameteri(texture_attrs.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+	glUseProgram(shader->program);
+
+	float* dim_color = deco_data.dim_color;
+
+	glUniformMatrix3fv(shader->proj, 1, GL_FALSE, gl_matrix);
+	glUniform1i(shader->tex, 0);
+	glUniform2f(shader->size, dst_box->width, dst_box->height);
+	glUniform2f(shader->position, dst_box->x, dst_box->y);
+	glUniform1f(shader->alpha, deco_data.alpha);
+	glUniform1f(shader->dim, deco_data.dim);
+	glUniform4f(shader->dim_color, dim_color[0], dim_color[1], dim_color[2], dim_color[3]);
+	glUniform1f(shader->has_titlebar, deco_data.has_titlebar);
+	glUniform1f(shader->saturation, deco_data.saturation);
+	glUniform1f(shader->radius, deco_data.corner_radius);
+
+	const GLfloat x1 = src_box->x / wlr_texture->width;
+	const GLfloat y1 = src_box->y / wlr_texture->height;
+	const GLfloat x2 = (src_box->x + src_box->width) / wlr_texture->width;
+	const GLfloat y2 = (src_box->y + src_box->height) / wlr_texture->height;
+	const GLfloat texcoord[] = {
+		x2, y1, // top right
+		x1, y1, // top left
+		x2, y2, // bottom right
+		x1, y2, // bottom left
+	};
+
+	glVertexAttribPointer(shader->pos_attrib, 2, GL_FLOAT, GL_FALSE, 0, verts);
+	glVertexAttribPointer(shader->tex_attrib, 2, GL_FLOAT, GL_FALSE, 0, texcoord);
+
+	glEnableVertexAttribArray(shader->pos_attrib);
+	glEnableVertexAttribArray(shader->tex_attrib);
+
+	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+	glDisableVertexAttribArray(shader->pos_attrib);
+	glDisableVertexAttribArray(shader->tex_attrib);
+
+	glBindTexture(texture_attrs.target, 0);
+
+	return true;
+}
+
+bool fx_render_texture_with_matrix(struct fx_renderer *renderer, struct wlr_texture *wlr_texture,
+		const struct wlr_box *dst_box, const float matrix[static 9],
+		struct decoration_data deco_data) {
+	struct wlr_fbox src_box = {
+		.x = 0,
+		.y = 0,
+		.width = wlr_texture->width,
+		.height = wlr_texture->height,
+	};
+	return fx_render_subtexture_with_matrix(renderer, wlr_texture, &src_box,
+			dst_box, matrix, deco_data);
+}
+
+void fx_render_rect(struct fx_renderer *renderer, const struct wlr_box *box,
+		const float color[static 4], const float projection[static 9]) {
+	if (box->width == 0 || box->height == 0) {
+		return;
+	}
+	assert(box->width > 0 && box->height > 0);
+	float matrix[9];
+	wlr_matrix_project_box(matrix, box, WL_OUTPUT_TRANSFORM_NORMAL, 0, projection);
+
+	float gl_matrix[9];
+	wlr_matrix_multiply(gl_matrix, renderer->projection, matrix);
+
+	// TODO: investigate why matrix is flipped prior to this cmd
+	// wlr_matrix_multiply(gl_matrix, flip_180, gl_matrix);
+
+	wlr_matrix_transpose(gl_matrix, gl_matrix);
+
+	if (color[3] == 1.0) {
+		glDisable(GL_BLEND);
+	} else {
+		glEnable(GL_BLEND);
+	}
+
+	glUseProgram(renderer->shaders.quad.program);
+
+	glUniformMatrix3fv(renderer->shaders.quad.proj, 1, GL_FALSE, gl_matrix);
+	glUniform4f(renderer->shaders.quad.color, color[0], color[1], color[2], color[3]);
+
+	glVertexAttribPointer(renderer->shaders.quad.pos_attrib, 2, GL_FLOAT, GL_FALSE,
+			0, verts);
+
+	glEnableVertexAttribArray(renderer->shaders.quad.pos_attrib);
+
+	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+	glDisableVertexAttribArray(renderer->shaders.quad.pos_attrib);
+}
+
+void fx_render_rounded_rect(struct fx_renderer *renderer, const struct wlr_box *box,
+		const float color[static 4], const float projection[static 9],
+		int radius, enum corner_location corner_location) {
+	if (box->width == 0 || box->height == 0) {
+		return;
+	}
+	assert(box->width > 0 && box->height > 0);
+
+	struct rounded_quad_shader *shader = NULL;
+
+	switch (corner_location) {
+		case ALL:
+			shader = &renderer->shaders.rounded_quad;
+			break;
+		case TOP_LEFT:
+			shader = &renderer->shaders.rounded_tl_quad;
+			break;
+		case TOP_RIGHT:
+			shader = &renderer->shaders.rounded_tr_quad;
+			break;
+		default:
+			sway_log(SWAY_ERROR, "Invalid Corner Location. Aborting render");
+			abort();
+	}
+
+	float matrix[9];
+	wlr_matrix_project_box(matrix, box, WL_OUTPUT_TRANSFORM_NORMAL, 0, projection);
+
+	float gl_matrix[9];
+	wlr_matrix_multiply(gl_matrix, renderer->projection, matrix);
+
+	// TODO: investigate why matrix is flipped prior to this cmd
+	// wlr_matrix_multiply(gl_matrix, flip_180, gl_matrix);
+
+	wlr_matrix_transpose(gl_matrix, gl_matrix);
+
+	glEnable(GL_BLEND);
+
+	glUseProgram(shader->program);
+
+	glUniformMatrix3fv(shader->proj, 1, GL_FALSE, gl_matrix);
+	glUniform4f(shader->color, color[0], color[1], color[2], color[3]);
+
+	// rounded corners
+	glUniform2f(shader->size, box->width, box->height);
+	glUniform2f(shader->position, box->x, box->y);
+	glUniform1f(shader->radius, radius);
+
+	glVertexAttribPointer(shader->pos_attrib, 2, GL_FLOAT, GL_FALSE,
+			0, verts);
+
+	glEnableVertexAttribArray(shader->pos_attrib);
+
+	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+	glDisableVertexAttribArray(shader->pos_attrib);
+}
+
+void fx_render_border_corner(struct fx_renderer *renderer, const struct wlr_box *box,
+		const float color[static 4], const float projection[static 9],
+		enum corner_location corner_location, int radius, int border_thickness) {
+	if (border_thickness == 0 || box->width == 0 || box->height == 0) {
+		return;
+	}
+	assert(box->width > 0 && box->height > 0);
+	float matrix[9];
+	wlr_matrix_project_box(matrix, box, WL_OUTPUT_TRANSFORM_NORMAL, 0, projection);
+
+	float gl_matrix[9];
+	wlr_matrix_multiply(gl_matrix, renderer->projection, matrix);
+
+	// TODO: investigate why matrix is flipped prior to this cmd
+	// wlr_matrix_multiply(gl_matrix, flip_180, gl_matrix);
+
+	wlr_matrix_transpose(gl_matrix, gl_matrix);
+
+	if (color[3] == 1.0 && !radius) {
+		glDisable(GL_BLEND);
+	} else {
+		glEnable(GL_BLEND);
+	}
+
+	glUseProgram(renderer->shaders.corner.program);
+
+	glUniformMatrix3fv(renderer->shaders.corner.proj, 1, GL_FALSE, gl_matrix);
+	glUniform4f(renderer->shaders.corner.color, color[0], color[1], color[2], color[3]);
+
+	glUniform1f(renderer->shaders.corner.is_top_left, corner_location == TOP_LEFT);
+	glUniform1f(renderer->shaders.corner.is_top_right, corner_location == TOP_RIGHT);
+	glUniform1f(renderer->shaders.corner.is_bottom_left, corner_location == BOTTOM_LEFT);
+	glUniform1f(renderer->shaders.corner.is_bottom_right, corner_location == BOTTOM_RIGHT);
+
+	glUniform2f(renderer->shaders.corner.position, box->x, box->y);
+	glUniform1f(renderer->shaders.corner.radius, radius);
+	glUniform2f(renderer->shaders.corner.half_size, box->width / 2.0, box->height / 2.0);
+	glUniform1f(renderer->shaders.corner.half_thickness, border_thickness / 2.0);
+
+	glVertexAttribPointer(renderer->shaders.corner.pos_attrib, 2, GL_FLOAT, GL_FALSE,
+			0, verts);
+
+	glEnableVertexAttribArray(renderer->shaders.corner.pos_attrib);
+
+	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+	glDisableVertexAttribArray(renderer->shaders.corner.pos_attrib);
+}
+
+// TODO: alpha input arg?
+void fx_render_box_shadow(struct fx_renderer *renderer, const struct wlr_box *box,
+		const float color[static 4], const float projection[static 9],
+		int corner_radius, float blur_sigma) {
+	if (box->width == 0 || box->height == 0) {
+		return;
+	}
+	assert(box->width > 0 && box->height > 0);
+	float matrix[9];
+	wlr_matrix_project_box(matrix, box, WL_OUTPUT_TRANSFORM_NORMAL, 0, projection);
+
+	float gl_matrix[9];
+	wlr_matrix_multiply(gl_matrix, renderer->projection, matrix);
+
+	// TODO: investigate why matrix is flipped prior to this cmd
+	// wlr_matrix_multiply(gl_matrix, flip_180, gl_matrix);
+
+	wlr_matrix_transpose(gl_matrix, gl_matrix);
+
+	// Init stencil work
+	// NOTE: Alpha needs to be set to 1.0 to be able to discard any "empty" pixels
+	const float col[4] = {0.0, 0.0, 0.0, 1.0};
+	struct wlr_box inner_box;
+	memcpy(&inner_box, box, sizeof(struct wlr_box));
+	inner_box.x += blur_sigma;
+	inner_box.y += blur_sigma;
+	inner_box.width -= blur_sigma * 2;
+	inner_box.height -= blur_sigma * 2;
+
+	glEnable(GL_STENCIL_TEST);
+	glClearStencil(0);
+	glClear(GL_STENCIL_BUFFER_BIT);
+
+	glStencilFunc(GL_ALWAYS, 1, 0xFF);
+	glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+	// Disable writing to color buffer
+	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+	// Draw the rounded rect as a mask
+	fx_render_rounded_rect(renderer, &inner_box, col, projection, corner_radius, ALL);
+	// Close the mask
+	glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
+	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+	// Reenable writing to color buffer
+	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+
+	// blending will practically always be needed (unless we have a madman
+	// who uses opaque shadows with zero sigma), so just enable it
+	glEnable(GL_BLEND);
+
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+	glUseProgram(renderer->shaders.box_shadow.program);
+
+	glUniformMatrix3fv(renderer->shaders.box_shadow.proj, 1, GL_FALSE, gl_matrix);
+	glUniform4f(renderer->shaders.box_shadow.color, color[0], color[1], color[2], color[3]);
+	glUniform1f(renderer->shaders.box_shadow.blur_sigma, blur_sigma);
+	glUniform1f(renderer->shaders.box_shadow.corner_radius, corner_radius);
+
+	glUniform2f(renderer->shaders.box_shadow.size, box->width, box->height);
+	glUniform2f(renderer->shaders.box_shadow.position, box->x, box->y);
+
+	glVertexAttribPointer(renderer->shaders.box_shadow.pos_attrib, 2, GL_FLOAT, GL_FALSE,
+			0, verts);
+
+	glEnableVertexAttribArray(renderer->shaders.box_shadow.pos_attrib);
+
+	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+	glDisableVertexAttribArray(renderer->shaders.box_shadow.pos_attrib);
+
+	glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+
+	glClearStencil(0);
+	glClear(GL_STENCIL_BUFFER_BIT);
+	glDisable(GL_STENCIL_TEST);
+}
diff --git a/sway/desktop/fx_renderer/matrix.c b/sway/desktop/fx_renderer/matrix.c
new file mode 100644
index 00000000..9c9dabec
--- /dev/null
+++ b/sway/desktop/fx_renderer/matrix.c
@@ -0,0 +1,70 @@
+#include <math.h>
+#include <string.h>
+#include <wlr/types/wlr_output.h>
+
+#include "sway/desktop/fx_renderer/matrix.h"
+
+static const float transforms[][9] = {
+	[WL_OUTPUT_TRANSFORM_NORMAL] = {
+		1.0f, 0.0f, 0.0f,
+		0.0f, 1.0f, 0.0f,
+		0.0f, 0.0f, 1.0f,
+	},
+	[WL_OUTPUT_TRANSFORM_90] = {
+		0.0f, 1.0f, 0.0f,
+		-1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f,
+	},
+	[WL_OUTPUT_TRANSFORM_180] = {
+		-1.0f, 0.0f, 0.0f,
+		0.0f, -1.0f, 0.0f,
+		0.0f, 0.0f, 1.0f,
+	},
+	[WL_OUTPUT_TRANSFORM_270] = {
+		0.0f, -1.0f, 0.0f,
+		1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f,
+	},
+	[WL_OUTPUT_TRANSFORM_FLIPPED] = {
+		-1.0f, 0.0f, 0.0f,
+		0.0f, 1.0f, 0.0f,
+		0.0f, 0.0f, 1.0f,
+	},
+	[WL_OUTPUT_TRANSFORM_FLIPPED_90] = {
+		0.0f, 1.0f, 0.0f,
+		1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f,
+	},
+	[WL_OUTPUT_TRANSFORM_FLIPPED_180] = {
+		1.0f, 0.0f, 0.0f,
+		0.0f, -1.0f, 0.0f,
+		0.0f, 0.0f, 1.0f,
+	},
+	[WL_OUTPUT_TRANSFORM_FLIPPED_270] = {
+		0.0f, -1.0f, 0.0f,
+		-1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f,
+	},
+};
+
+void matrix_projection(float mat[static 9], int width, int height,
+		enum wl_output_transform transform) {
+	memset(mat, 0, sizeof(*mat) * 9);
+
+	const float *t = transforms[transform];
+	float x = 2.0f / width;
+	float y = 2.0f / height;
+
+	// Rotation + reflection
+	mat[0] = x * t[0];
+	mat[1] = x * t[1];
+	mat[3] = y * -t[3];
+	mat[4] = y * -t[4];
+
+	// Translation
+	mat[2] = -copysign(1.0f, mat[0] + mat[1]);
+	mat[5] = -copysign(1.0f, mat[3] + mat[4]);
+
+	// Identity
+	mat[8] = 1.0f;
+}
diff --git a/sway/desktop/fx_renderer/shaders/box_shadow.frag b/sway/desktop/fx_renderer/shaders/box_shadow.frag
new file mode 100644
index 00000000..c9b2b91f
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/box_shadow.frag
@@ -0,0 +1,74 @@
+// Writeup: https://madebyevan.com/shaders/fast-rounded-rectangle-shadows/
+
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+uniform vec2 position;
+uniform vec2 size;
+uniform float blur_sigma;
+uniform float corner_radius;
+
+float gaussian(float x, float sigma) {
+    const float pi = 3.141592653589793;
+    return exp(-(x * x) / (2.0 * sigma * sigma)) / (sqrt(2.0 * pi) * sigma);
+}
+
+// approximates the error function, needed for the gaussian integral
+vec2 erf(vec2 x) {
+    vec2 s = sign(x), a = abs(x);
+    x = 1.0 + (0.278393 + (0.230389 + 0.078108 * (a * a)) * a) * a;
+    x *= x;
+    return s - s / (x * x);
+}
+
+// return the blurred mask along the x dimension
+float roundedBoxShadowX(float x, float y, float sigma, float corner, vec2 halfSize) {
+    float delta = min(halfSize.y - corner - abs(y), 0.0);
+    float curved = halfSize.x - corner + sqrt(max(0.0, corner * corner - delta * delta));
+    vec2 integral = 0.5 + 0.5 * erf((x + vec2(-curved, curved)) * (sqrt(0.5) / sigma));
+    return integral.y - integral.x;
+}
+
+// return the mask for the shadow of a box from lower to upper
+float roundedBoxShadow(vec2 lower, vec2 upper, vec2 point, float sigma, float corner_radius) {
+    // Center everything to make the math easier
+    vec2 center = (lower + upper) * 0.5;
+    vec2 halfSize = (upper - lower) * 0.5;
+    point -= center;
+
+    // The signal is only non-zero in a limited range, so don't waste samples
+    float low = point.y - halfSize.y;
+    float high = point.y + halfSize.y;
+    float start = clamp(-3.0 * sigma, low, high);
+    float end = clamp(3.0 * sigma, low, high);
+
+    // Accumulate samples (we can get away with surprisingly few samples)
+    float step = (end - start) / 4.0;
+    float y = start + step * 0.5;
+    float value = 0.0;
+    for (int i = 0; i < 4; i++) {
+        value += roundedBoxShadowX(point.x, point.y - y, sigma, corner_radius, halfSize) * gaussian(y, sigma) * step;
+        y += step;
+    }
+
+    return value;
+}
+
+// per-pixel "random" number between 0 and 1
+float random() {
+    return fract(sin(dot(vec2(12.9898, 78.233), gl_FragCoord.xy)) * 43758.5453);
+}
+
+void main() {
+    float frag_alpha = v_color.a * roundedBoxShadow(
+            position + blur_sigma,
+            position + size - blur_sigma,
+            gl_FragCoord.xy, blur_sigma * 0.5,
+            corner_radius);
+
+    // dither the alpha to break up color bands
+    frag_alpha += (random() - 0.5) / 128.0;
+
+    gl_FragColor = vec4(v_color.rgb, frag_alpha);
+}
diff --git a/sway/desktop/fx_renderer/shaders/common.vert b/sway/desktop/fx_renderer/shaders/common.vert
new file mode 100644
index 00000000..811e0f2d
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/common.vert
@@ -0,0 +1,12 @@
+uniform mat3 proj;
+uniform vec4 color;
+attribute vec2 pos;
+attribute vec2 texcoord;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+void main() {
+    gl_Position = vec4(proj * vec3(pos, 1.0), 1.0);
+    v_color = color;
+    v_texcoord = texcoord;
+}
diff --git a/sway/desktop/fx_renderer/shaders/corner.frag b/sway/desktop/fx_renderer/shaders/corner.frag
new file mode 100644
index 00000000..7699299a
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/corner.frag
@@ -0,0 +1,36 @@
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+uniform bool is_top_left;
+uniform bool is_top_right;
+uniform bool is_bottom_left;
+uniform bool is_bottom_right;
+
+uniform vec2 position;
+uniform float radius;
+uniform vec2 half_size;
+uniform float half_thickness;
+
+float roundedBoxSDF(vec2 center, vec2 size, float radius) {
+    return length(max(abs(center) - size + radius, 0.0)) - radius;
+}
+
+void main() {
+    vec2 center = gl_FragCoord.xy - position - half_size;
+    float distance = roundedBoxSDF(center, half_size - half_thickness, radius + half_thickness);
+    float smoothedAlphaOuter = 1.0 - smoothstep(-1.0, 1.0, distance - half_thickness);
+    // Create an inner circle that isn't as anti-aliased as the outer ring
+    float smoothedAlphaInner = 1.0 - smoothstep(-1.0, 0.5, distance + half_thickness);
+    gl_FragColor = mix(vec4(0), v_color, smoothedAlphaOuter - smoothedAlphaInner);
+
+    if (is_top_left && (center.y > 0.0 || center.x > 0.0)) {
+        discard;
+    } else if (is_top_right && (center.y > 0.0 || center.x < 0.0)) {
+        discard;
+    } else if (is_bottom_left && (center.y < 0.0 || center.x > 0.0)) {
+        discard;
+    } else if (is_bottom_right && (center.y < 0.0 || center.x < 0.0)) {
+        discard;
+    }
+}
diff --git a/sway/desktop/fx_renderer/shaders/embed.sh b/sway/desktop/fx_renderer/shaders/embed.sh
new file mode 100644
index 00000000..47f07892
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/embed.sh
@@ -0,0 +1,11 @@
+#!/bin/sh -eu
+
+var=${1:-data}
+hex="$(od -A n -t x1 -v)"
+
+echo "static const char $var[] = {"
+for byte in $hex; do
+    echo "	0x$byte,"
+done
+echo "	0x00,"
+echo "};"
diff --git a/sway/desktop/fx_renderer/shaders/meson.build b/sway/desktop/fx_renderer/shaders/meson.build
new file mode 100644
index 00000000..6c0dd1d3
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/meson.build
@@ -0,0 +1,23 @@
+embed = find_program('./embed.sh', native: true)
+
+shaders = [
+    'box_shadow.frag',
+    'common.vert',
+    'corner.frag',
+    'quad.frag',
+    'quad_round.frag',
+    'tex.frag',
+]
+
+foreach name : shaders
+    output = name.underscorify() + '_src.h'
+    var = name.underscorify() + '_src'
+    sway_sources += custom_target(
+        output,
+        command: [embed, var],
+        input: name,
+        output: output,
+        feed: true,
+        capture: true,
+    )
+endforeach
diff --git a/sway/desktop/fx_renderer/shaders/quad.frag b/sway/desktop/fx_renderer/shaders/quad.frag
new file mode 100644
index 00000000..7c763272
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/quad.frag
@@ -0,0 +1,7 @@
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+void main() {
+    gl_FragColor = v_color;
+}
diff --git a/sway/desktop/fx_renderer/shaders/quad_round.frag b/sway/desktop/fx_renderer/shaders/quad_round.frag
new file mode 100644
index 00000000..4dcf0c53
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/quad_round.frag
@@ -0,0 +1,37 @@
+#define SOURCE_QUAD_ROUND 1
+#define SOURCE_QUAD_ROUND_TOP_LEFT 2
+#define SOURCE_QUAD_ROUND_TOP_RIGHT 3
+
+#if !defined(SOURCE)
+#error "Missing shader preamble"
+#endif
+
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+uniform vec2 size;
+uniform vec2 position;
+uniform float radius;
+
+vec2 getCornerDist() {
+#if SOURCE == SOURCE_QUAD_ROUND
+    vec2 half_size = size * 0.5;
+    return abs(gl_FragCoord.xy - position - half_size) - half_size + radius;
+#elif SOURCE == SOURCE_QUAD_ROUND_TOP_LEFT
+    return abs(gl_FragCoord.xy - position - size) - size + radius;
+#elif SOURCE == SOURCE_QUAD_ROUND_TOP_RIGHT
+    return abs(gl_FragCoord.xy - position - vec2(0, size.y)) - size + radius;
+#endif
+}
+
+void main() {
+    vec2 q = getCornerDist();
+    float dist = min(max(q.x,q.y), 0.0) + length(max(q, 0.0)) - radius;
+    float smoothedAlpha = 1.0 - smoothstep(-1.0, 0.5, dist);
+    gl_FragColor = mix(vec4(0), v_color, smoothedAlpha);
+
+    if (gl_FragColor.a == 0.0) {
+        discard;
+    }
+}
diff --git a/sway/desktop/fx_renderer/shaders/tex.frag b/sway/desktop/fx_renderer/shaders/tex.frag
new file mode 100644
index 00000000..817b838c
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/tex.frag
@@ -0,0 +1,62 @@
+#define SOURCE_TEXTURE_RGBA 1
+#define SOURCE_TEXTURE_RGBX 2
+#define SOURCE_TEXTURE_EXTERNAL 3
+
+#if !defined(SOURCE)
+#error "Missing shader preamble"
+#endif
+
+#if SOURCE == SOURCE_TEXTURE_EXTERNAL
+#extension GL_OES_EGL_image_external : require
+#endif
+
+precision mediump float;
+
+varying vec2 v_texcoord;
+
+#if SOURCE == SOURCE_TEXTURE_EXTERNAL
+uniform samplerExternalOES tex;
+#elif SOURCE == SOURCE_TEXTURE_RGBA || SOURCE == SOURCE_TEXTURE_RGBX
+uniform sampler2D tex;
+#endif
+
+uniform float alpha;
+uniform float dim;
+uniform vec4 dim_color;
+uniform vec2 size;
+uniform vec2 position;
+uniform float radius;
+uniform bool has_titlebar;
+uniform float saturation;
+
+const vec3 saturation_weight = vec3(0.2125, 0.7154, 0.0721);
+
+vec4 sample_texture() {
+#if SOURCE == SOURCE_TEXTURE_RGBA || SOURCE == SOURCE_TEXTURE_EXTERNAL
+    return texture2D(tex, v_texcoord);
+#elif SOURCE == SOURCE_TEXTURE_RGBX
+    return vec4(texture2D(tex, v_texcoord).rgb, 1.0);
+#endif
+}
+
+void main() {
+    vec4 color = sample_texture();
+    // Saturation
+    if (saturation != 1.0) {
+        vec4 pixColor = texture2D(tex, v_texcoord);
+        vec3 irgb = pixColor.rgb;
+        vec3 target = vec3(dot(irgb, saturation_weight));
+        color = vec4(mix(target, irgb, saturation), pixColor.a);
+    }
+    // Dimming
+    gl_FragColor = mix(color, dim_color, dim) * alpha;
+
+    if (!has_titlebar || gl_FragCoord.y - position.y > radius) {
+        vec2 corner_distance = min(gl_FragCoord.xy - position, size + position - gl_FragCoord.xy);
+        if (max(corner_distance.x, corner_distance.y) < radius) {
+            float d = radius - distance(corner_distance, vec2(radius));
+            float smooth = smoothstep(-1.0, 0.5, d);
+            gl_FragColor = mix(vec4(0), gl_FragColor, smooth);
+        }
+    }
+}