fix,chore: misc animation, move screen shaders to get_screen_shader_source backend-specific function

Author: dy-tea

include/effects_backend.h

@@ -154,6 +154,7 @@ typedef struct effects_backend_t {
 	bool (*capture_readback)(struct wlr_buffer *capture_buffer, be_output_state_t *state,
 		uint64_t dst_fbo, int dst_w, int dst_h, int src_w, int src_h, uint64_t *out_tex);
 
+	const char *(*get_screen_shader_source)(const char *name);
 	bool (*compile_screen_shader)(const char *frag_src);
 	void (*destroy_screen_shader)(void);
 } effects_backend_t;

src/animation.c

@@ -897,8 +897,6 @@ static void update_blur_for_slide_animation(output_t *output, animation_entry_t
 		return;
 	if (!tl->blur || !tl->blur->blur_node)
 		return;
-	if (!pixman_region32_empty(&tl->blur->blur_region))
-		return;
 	if (!tl->blur->blur_buf)
 		return;
 
@@ -908,6 +906,54 @@ static void update_blur_for_slide_animation(output_t *output, animation_entry_t
 	int x = (int)(entry->from.x + (entry->to.x - entry->from.x) * e);
 	int y = (int)(entry->from.y + (entry->to.y - entry->from.y) * e);
 
+	if (!pixman_region32_empty(&tl->blur->blur_region)) {
+		int blur_r_x = tl->blur->blur_region.extents.x1;
+		int blur_r_y = tl->blur->blur_region.extents.y1;
+		int blur_r_w = tl->blur->blur_region.extents.x2 - blur_r_x;
+		int blur_r_h = tl->blur->blur_region.extents.y2 - blur_r_y;
+
+		int r_x = x + blur_r_x, r_y = y + blur_r_y;
+
+		float bw = (float)output->width;
+		float bh = (float)output->height;
+		float sx = (float)(r_x - output->lx);
+		float sy = (float)(r_y - output->ly);
+		float sw = (float)blur_r_w, sh = (float)blur_r_h;
+
+		if (sx < 0.0f) {
+			sw += sx;
+			sx = 0.0f;
+		}
+		if (sy < 0.0f) {
+			sh += sy;
+			sy = 0.0f;
+		}
+		if (sx >= bw || sy >= bh || sw <= 0.0f || sh <= 0.0f)
+			return;
+		if (sx + sw > bw)
+			sw = bw - sx;
+		if (sy + sh > bh)
+			sh = bh - sy;
+		if (sw <= 0.0f || sh <= 0.0f)
+			return;
+
+		struct wlr_fbox src = {
+			.x = sx,
+			.y = sy,
+			.width = sw,
+			.height = sh
+		};
+		int dw = (int)sw, dh = (int)sh;
+
+		int offset_x = (r_x < output->lx) ? (output->lx - r_x) : 0;
+		int offset_y = (r_y < output->ly) ? (output->ly - r_y) : 0;
+
+		wlr_scene_node_set_position(&tl->blur->blur_node->node, blur_r_x + offset_x, blur_r_y + offset_y);
+		wlr_scene_buffer_set_source_box(tl->blur->blur_node, &src);
+		wlr_scene_buffer_set_dest_size(tl->blur->blur_node, dw, dh);
+		return;
+	}
+
 	struct wlr_box r;
 	if (c->state == STATE_FULLSCREEN)
 		r = output->rectangle;

src/effects.c

@@ -1,10 +1,6 @@
 #include "animation.h"
 #include "effects.h"
 #include "effects_backend.h"
-#include "gl_grayscale_frag_src.h"
-#include "gl_invert_frag_src.h"
-#include "gl_nightlight_frag_src.h"
-#include "gl_sepia_frag_src.h"
 #include "layer.h"
 #include "output.h"
 #include "server.h"
@@ -2179,16 +2175,7 @@ bool screen_shader_set(const char *name) {
 		return true;
 	}
 
-	const char *frag_src = NULL;
-	if (strcmp(name, "grayscale") == 0) {
-		frag_src = gl_grayscale_frag_src;
-	} else if (strcmp(name, "invert") == 0) {
-		frag_src = gl_invert_frag_src;
-	} else if (strcmp(name, "sepia") == 0) {
-		frag_src = gl_sepia_frag_src;
-	} else if (strcmp(name, "nightlight") == 0) {
-		frag_src = gl_nightlight_frag_src;
-	}
+	const char *frag_src = effects_backend->get_screen_shader_source(name);
 
 	if (!frag_src)
 		return false;

src/effects_gles2.c

@@ -6,6 +6,7 @@
 #include <GLES2/gl2ext.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
 #include <wlr/config.h>
 #include <wlr/render/allocator.h>
@@ -16,6 +17,11 @@
 #include <wlr/types/wlr_buffer.h>
 #include <wlr/util/log.h>
 
+#include "gl_grayscale_frag_src.h"
+#include "gl_invert_frag_src.h"
+#include "gl_nightlight_frag_src.h"
+#include "gl_sepia_frag_src.h"
+
 #ifdef WLR_HAS_GLES2_RENDERER
 const struct wlr_drm_format_set *wlr_renderer_get_render_formats(struct wlr_renderer *renderer);
 
@@ -1061,6 +1067,18 @@ static void gles2_destroy_screen_shader(void) {
 	g->screen_shader_u_time = -1;
 }
 
+static const char *gles2_get_screen_shader_source(const char *name) {
+	if (strcmp(name, "grayscale") == 0)
+		return gl_grayscale_frag_src;
+	if (strcmp(name, "invert") == 0)
+		return gl_invert_frag_src;
+	if (strcmp(name, "sepia") == 0)
+		return gl_sepia_frag_src;
+	if (strcmp(name, "nightlight") == 0)
+		return gl_nightlight_frag_src;
+	return NULL;
+}
+
 const effects_backend_t gles2_backend = {
 	.init = gles2_init,
 	.fini = gles2_fini,
@@ -1080,6 +1098,7 @@ const effects_backend_t gles2_backend = {
 	.apply_corner_mask = gles2_apply_corner_mask,
 	.apply_screen_shader = gles2_apply_screen_shader,
 	.capture_readback = gles2_capture_readback,
+	.get_screen_shader_source = gles2_get_screen_shader_source,
 	.compile_screen_shader = gles2_compile_screen_shader,
 	.destroy_screen_shader = gles2_destroy_screen_shader,
 };

src/effects_vk.c

@@ -18,6 +18,11 @@
 #include <wlr/render/wlr_texture.h>
 #include <wlr/types/wlr_buffer.h>
 
+#include "vk_grayscale_frag_src.h"
+#include "vk_invert_frag_src.h"
+#include "vk_nightlight_frag_src.h"
+#include "vk_sepia_frag_src.h"
+
 const struct wlr_drm_format_set *wlr_renderer_get_render_formats(struct wlr_renderer *renderer);
 
 #include "vk_blit_frag_src.h"
@@ -2245,6 +2250,18 @@ static void vk_destroy_screen_shader(void) {
 	}
 }
 
+static const char *vk_get_screen_shader_source(const char *name) {
+	if (strcmp(name, "grayscale") == 0)
+		return vk_grayscale_frag_src;
+	if (strcmp(name, "invert") == 0)
+		return vk_invert_frag_src;
+	if (strcmp(name, "sepia") == 0)
+		return vk_sepia_frag_src;
+	if (strcmp(name, "nightlight") == 0)
+		return vk_nightlight_frag_src;
+	return NULL;
+}
+
 const effects_backend_t vk_backend = {
 	.init = vk_init,
 	.fini = vk_fini,
@@ -2264,6 +2281,7 @@ const effects_backend_t vk_backend = {
 	.apply_corner_mask = vk_apply_corner_mask,
 	.apply_screen_shader = vk_apply_screen_shader,
 	.capture_readback = vk_capture_readback,
+	.get_screen_shader_source = vk_get_screen_shader_source,
 	.compile_screen_shader = vk_compile_screen_shader,
 	.destroy_screen_shader = vk_destroy_screen_shader,
 };

src/output.c

@@ -227,13 +227,13 @@ static void output_repaint(output_t *output) {
 	clock_gettime(CLOCK_MONOTONIC, &now);
 	bool animating = animation_update_output(output, now);
 
-	if (effects_state.available && (fs_effects || !has_fs))
-		effects_output_frame(output, scene_output);
-
 	// ensure blur nodes track animated window positions during workspace slide
 	if (animating)
 		animation_update_slide_blur(output);
 
+	if (effects_state.available && (fs_effects || !has_fs))
+		effects_output_frame(output, scene_output);
+
 	if (has_fs && !fs_effects && output_try_direct_scanout(output)) {
 		clock_gettime(CLOCK_MONOTONIC, &now);
 		wlr_scene_output_send_frame_done(scene_output, &now);

src/shaders/meson.build

@@ -66,6 +66,12 @@ vk_shaders = [
 
 	# Shadows
 	'shadow.frag',
+
+	# Fullscreen effects
+	'grayscale.frag',
+	'invert.frag',
+	'nightlight.frag',
+	'sepia.frag',
 ]
 
 foreach shader : vk_shaders

src/shaders/vulkan/grayscale.frag

@@ -0,0 +1,9 @@
+#version 450
+layout(binding = 0) uniform sampler2D tex;
+layout(location = 0) in vec2 v_uv;
+layout(location = 0) out vec4 fragColor;
+void main() {
+  vec3 c = texture(tex, v_uv).rgb;
+  float g = dot(c, vec3(0.2126, 0.7152, 0.0722));
+  fragColor = vec4(g, g, g, 1.0);
+}

src/shaders/vulkan/invert.frag

@@ -0,0 +1,8 @@
+#version 450
+layout(binding = 0) uniform sampler2D tex;
+layout(location = 0) in vec2 v_uv;
+layout(location = 0) out vec4 fragColor;
+void main() {
+  vec3 c = texture(tex, v_uv).rgb;
+  fragColor = vec4(1.0 - c, 1.0);
+}

src/shaders/vulkan/nightlight.frag

@@ -0,0 +1,11 @@
+#version 450
+layout(binding = 0) uniform sampler2D tex;
+layout(location = 0) in vec2 v_uv;
+layout(location = 0) out vec4 fragColor;
+void main() {
+  vec3 c = texture(tex, v_uv).rgb;
+  c.r = min(c.r * 1.05, 1.0);
+  c.g = c.g * 0.92;
+  c.b = c.b * 0.75;
+  fragColor = vec4(c, 1.0);
+}