mirrors/maomaowm
1
0
Fork 0
mirror of https://github.com/DreamMaoMao/maomaowm.git synced 2025-11-08 13:29:56 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

back: no effect

Browse source
This commit is contained in:
DreamMaoMao 2025-07-09 11:44:04 +08:00
parent e374e9c530
commit 43081f385e
8 changed files with 62 additions and 578 deletions
Download patch file Download diff file Expand all files Collapse all files

2
meson.build
View file

@ -38,7 +38,6 @@ xkbcommon_dep = dependency('xkbcommon')
libinput_dep = dependency('libinput') libinput_dep = dependency('libinput')
libwayland_client_dep = dependency('wayland-client') libwayland_client_dep = dependency('wayland-client')
pcre2_dep = dependency('libpcre2-8') pcre2_dep = dependency('libpcre2-8')
libscenefx_dep = dependency('scenefx-0.4',version: '>=0.4.1')
# 获取 Git Commit Hash 和最新的 tag # 获取 Git Commit Hash 和最新的 tag
@ -76,7 +75,6 @@ executable('maomao',
libm, libm,
xcb, xcb,
xlibs, xlibs,
libscenefx_dep,
wayland_server_dep, wayland_server_dep,
wlroots_dep, wlroots_dep,
xkbcommon_dep, xkbcommon_dep,

219
src/animation/client.h
View file

@ -30,26 +30,6 @@ void apply_opacity_to_rect_nodes(Client *c, struct wlr_scene_node *node,
} }
} }
enum corner_location set_client_corner_location(Client *c) {
enum corner_location current_corner_location = CORNER_LOCATION_ALL;
struct wlr_box target_geom = animations ? c->animation.current : c->geom;
if (target_geom.x + border_radius <= c->mon->m.x) {
current_corner_location &= ~CORNER_LOCATION_LEFT; // 清除左标志位
}
if (target_geom.x + target_geom.width - border_radius >=
c->mon->m.x + c->mon->m.width) {
current_corner_location &= ~CORNER_LOCATION_RIGHT; // 清除右标志位
}
if (target_geom.y + border_radius <= c->mon->m.y) {
current_corner_location &= ~CORNER_LOCATION_TOP; // 清除上标志位
}
if (target_geom.y + target_geom.height - border_radius >=
c->mon->m.y + c->mon->m.height) {
current_corner_location &= ~CORNER_LOCATION_BOTTOM; // 清除下标志位
}
return current_corner_location;
}
int is_special_animaiton_rule(Client *c) { int is_special_animaiton_rule(Client *c) {
int visible_client_number = 0; int visible_client_number = 0;
Client *count_c; Client *count_c;
@ -216,9 +196,6 @@ void scene_buffer_apply_effect(struct wlr_scene_buffer *buffer, int sx, int sy,
if (wlr_xdg_popup_try_from_wlr_surface(surface) != NULL) if (wlr_xdg_popup_try_from_wlr_surface(surface) != NULL)
return; return;
wlr_scene_buffer_set_corner_radius(buffer, border_radius,
scale_data->corner_location);
float target_opacity = scale_data->percent + fadein_begin_opacity; float target_opacity = scale_data->percent + fadein_begin_opacity;
if (target_opacity > scale_data->opacity) { if (target_opacity > scale_data->opacity) {
target_opacity = scale_data->opacity; target_opacity = scale_data->opacity;
@ -239,128 +216,26 @@ void buffer_set_effect(Client *c, animationScale data) {
if (c == grabc) if (c == grabc)
data.should_scale = false; data.should_scale = false;
if (c->isfullscreen || (no_radius_when_single && c->mon &&
c->mon->visible_tiling_clients == 1)) {
data.corner_location = CORNER_LOCATION_NONE;
}
wlr_scene_node_for_each_buffer(&c->scene_surface->node, wlr_scene_node_for_each_buffer(&c->scene_surface->node,
scene_buffer_apply_effect, &data); scene_buffer_apply_effect, &data);
} }
void client_draw_shadow(Client *c) { void apply_border(Client *c) {
bool hit_no_border = false;
if (c->iskilling || !client_surface(c)->mapped) if (c->iskilling || !client_surface(c)->mapped)
return; return;
if (!shadows || (!c->isfloating && shadow_only_floating)) { hit_no_border = check_hit_no_border(c);
wlr_scene_shadow_set_size(c->shadow, 0, 0);
return;
}
bool hit_no_border = check_hit_no_border(c);
enum corner_location current_corner_location =
c->isfullscreen || (no_radius_when_single && c->mon &&
c->mon->visible_tiling_clients == 1)
? CORNER_LOCATION_NONE
: CORNER_LOCATION_ALL;
unsigned int bwoffset = c->bw != 0 && hit_no_border ? c->bw : 0;
uint32_t width, height;
client_actual_size(c, &width, &height);
uint32_t delta = shadows_size + c->bw - bwoffset;
/* we calculate where to clip the shadow */
struct wlr_box client_box = {
.x = bwoffset,
.y = bwoffset,
.width = width - 2 * bwoffset,
.height = height - 2 * bwoffset,
};
struct wlr_box shadow_box = {
.x = shadows_position_x,
.y = shadows_position_y,
.width = width + 2 * delta,
.height = height + 2 * delta,
};
struct wlr_box intersection_box;
wlr_box_intersection(&intersection_box, &client_box, &shadow_box);
/* clipped region takes shadow relative coords, so we translate everything
* by its position */
intersection_box.x -= shadows_position_x;
intersection_box.y -= shadows_position_y;
struct clipped_region clipped_region = {
.area = intersection_box,
.corner_radius = border_radius,
.corners = current_corner_location,
};
struct wlr_box absolute_shadow_box = {
.x = shadow_box.x + c->animation.current.x,
.y = shadow_box.y + c->animation.current.y,
.width = shadow_box.width,
.height = shadow_box.height,
};
int right_offset, bottom_offset, left_offset, top_offset;
if (c == grabc) {
right_offset = 0;
bottom_offset = 0;
left_offset = 0;
top_offset = 0;
} else {
right_offset =
GEZERO(absolute_shadow_box.x + absolute_shadow_box.width -
c->mon->m.x - c->mon->m.width);
bottom_offset =
GEZERO(absolute_shadow_box.y + absolute_shadow_box.height -
c->mon->m.y - c->mon->m.height);
left_offset = GEZERO(c->mon->m.x - absolute_shadow_box.x);
top_offset = GEZERO(c->mon->m.y - absolute_shadow_box.y);
}
left_offset = MIN(left_offset, shadow_box.width);
right_offset = MIN(right_offset, shadow_box.width);
top_offset = MIN(top_offset, shadow_box.height);
bottom_offset = MIN(bottom_offset, shadow_box.height);
wlr_scene_node_set_position(&c->shadow->node, shadow_box.x + left_offset,
shadow_box.y + top_offset);
wlr_scene_shadow_set_size(
c->shadow, GEZERO(shadow_box.width - left_offset - right_offset),
GEZERO(shadow_box.height - top_offset - bottom_offset));
clipped_region.area.x = clipped_region.area.x - left_offset;
clipped_region.area.y = clipped_region.area.y - top_offset;
wlr_scene_shadow_set_clipped_region(c->shadow, clipped_region);
}
void apply_border(Client *c) {
if (!c || c->iskilling || !client_surface(c)->mapped)
return;
bool hit_no_border = check_hit_no_border(c);
enum corner_location current_corner_location =
c->isfullscreen || (no_radius_when_single && c->mon &&
c->mon->visible_tiling_clients == 1)
? CORNER_LOCATION_NONE
: CORNER_LOCATION_ALL;
// Handle no-border cases
if (hit_no_border && smartgaps) { if (hit_no_border && smartgaps) {
c->bw = 0; c->bw = 0;
c->fake_no_border = true; c->fake_no_border = true;
} else if (hit_no_border && !smartgaps) { } else if (hit_no_border && !smartgaps) {
wlr_scene_rect_set_size(c->border, 0, 0); set_rect_size(c->border[0], 0, 0);
set_rect_size(c->border[1], 0, 0);
set_rect_size(c->border[2], 0, 0);
set_rect_size(c->border[3], 0, 0);
wlr_scene_node_set_position(&c->scene_surface->node, c->bw, c->bw); wlr_scene_node_set_position(&c->scene_surface->node, c->bw, c->bw);
c->fake_no_border = true; c->fake_no_border = true;
return; return;
@ -369,7 +244,7 @@ void apply_border(Client *c) {
c->fake_no_border = false; c->fake_no_border = false;
} }
struct wlr_box clip_box = c->animation.current; struct wlr_box fullgeom = c->animation.current;
// 一但在GEZERO如果使用无符号，那么其他数据也会转换为无符号导致没有负数出错 // 一但在GEZERO如果使用无符号，那么其他数据也会转换为无符号导致没有负数出错
int bw = (int)c->bw; int bw = (int)c->bw;
@ -392,49 +267,48 @@ void apply_border(Client *c) {
top_offset = GEZERO(c->mon->m.y - c->animation.current.y); top_offset = GEZERO(c->mon->m.y - c->animation.current.y);
} }
int inner_surface_width = GEZERO(clip_box.width - 2 * bw); int border_up_width = GEZERO(fullgeom.width - left_offset - right_offset);
int inner_surface_height = GEZERO(clip_box.height - 2 * bw); int border_up_height =
GEZERO(bw - top_offset - GEZERO(bottom_offset + bw - fullgeom.height));
int inner_surface_x = GEZERO(bw - left_offset); int border_down_width = GEZERO(fullgeom.width - left_offset - right_offset);
int inner_surface_y = GEZERO(bw - top_offset); int border_down_height =
GEZERO(bw - bottom_offset - GEZERO(top_offset + bw - fullgeom.height));
int rect_x = left_offset; int border_left_width =
int rect_y = top_offset; GEZERO(bw - left_offset - GEZERO(right_offset + bw - fullgeom.width));
int border_left_height =
GEZERO(fullgeom.height - top_offset - bottom_offset);
int rect_width = int border_right_width =
GEZERO(c->animation.current.width - left_offset - right_offset); GEZERO(bw - right_offset - GEZERO(left_offset + bw - fullgeom.width));
int rect_height = int border_right_height =
GEZERO(c->animation.current.height - top_offset - bottom_offset); GEZERO(fullgeom.height - top_offset - bottom_offset);
if (left_offset > c->bw) int border_up_x = GEZERO(left_offset);
inner_surface_width = inner_surface_width - left_offset + c->bw; int border_up_y = GEZERO(top_offset);
if (top_offset > c->bw) int border_down_x = GEZERO(left_offset);
inner_surface_height = inner_surface_height - top_offset + c->bw; int border_down_y = GEZERO(fullgeom.height - bw);
if (right_offset > 0) { int border_left_x = GEZERO(left_offset);
inner_surface_width = int border_left_y = GEZERO(top_offset);
MIN(clip_box.width, inner_surface_width + right_offset);
}
if (bottom_offset > 0) { int border_right_x = GEZERO(fullgeom.width - bw);
inner_surface_height = int border_right_y = GEZERO(top_offset);
MIN(clip_box.height, inner_surface_height + bottom_offset);
}
struct clipped_region clipped_region = {
.area = {inner_surface_x, inner_surface_y, inner_surface_width,
inner_surface_height},
.corner_radius = border_radius,
.corners = current_corner_location,
};
wlr_scene_node_set_position(&c->scene_surface->node, c->bw, c->bw); wlr_scene_node_set_position(&c->scene_surface->node, c->bw, c->bw);
wlr_scene_rect_set_size(c->border, rect_width, rect_height); set_rect_size(c->border[0], border_up_width, border_up_height);
wlr_scene_node_set_position(&c->border->node, rect_x, rect_y); set_rect_size(c->border[1], border_down_width, border_down_height);
wlr_scene_rect_set_corner_radius(c->border, border_radius, set_rect_size(c->border[2], border_left_width, border_left_height);
current_corner_location); set_rect_size(c->border[3], border_right_width, border_right_height);
wlr_scene_rect_set_clipped_region(c->border, clipped_region); wlr_scene_node_set_position(&c->border[0]->node, border_up_x, border_up_y);
wlr_scene_node_set_position(&c->border[2]->node, border_left_x,
border_left_y);
wlr_scene_node_set_position(&c->border[1]->node, border_down_x,
border_down_y);
wlr_scene_node_set_position(&c->border[3]->node, border_right_x,
border_right_y);
} }
struct ivec2 clip_to_hide(Client *c, struct wlr_box *clip_box) { struct ivec2 clip_to_hide(Client *c, struct wlr_box *clip_box) {
@ -511,9 +385,6 @@ void client_apply_clip(Client *c) {
struct ivec2 offset; struct ivec2 offset;
animationScale scale_data; animationScale scale_data;
enum corner_location current_corner_location =
set_client_corner_location(c);
float percent = float percent =
c->animation.action == OPEN && animation_fade_in && !c->nofadein c->animation.action == OPEN && animation_fade_in && !c->nofadein
? (double)c->animation.passed_frames / c->animation.total_frames ? (double)c->animation.passed_frames / c->animation.total_frames
@ -535,7 +406,6 @@ void client_apply_clip(Client *c) {
offset = clip_to_hide(c, &clip_box); offset = clip_to_hide(c, &clip_box);
apply_border(c); apply_border(c);
client_draw_shadow(c);
scale_data.opacity = c->isfullscreen ? 1 scale_data.opacity = c->isfullscreen ? 1
: c == selmon->sel ? c->focused_opacity : c == selmon->sel ? c->focused_opacity
@ -546,8 +416,8 @@ void client_apply_clip(Client *c) {
} }
wlr_scene_subsurface_tree_set_clip(&c->scene_surface->node, &clip_box); wlr_scene_subsurface_tree_set_clip(&c->scene_surface->node, &clip_box);
buffer_set_effect(c, (animationScale){0, 0, 0, 0, opacity, opacity, buffer_set_effect(
current_corner_location, false}); c, (animationScale){0, 0, 0, 0, opacity, opacity, false});
return; return;
} }
@ -575,7 +445,6 @@ void client_apply_clip(Client *c) {
// 应用窗口装饰 // 应用窗口装饰
apply_border(c); apply_border(c);
client_draw_shadow(c);
// 如果窗口剪切区域已经剪切到0，则不渲染窗口表面 // 如果窗口剪切区域已经剪切到0，则不渲染窗口表面
if (clip_box.width <= 0 || clip_box.height <= 0) { if (clip_box.width <= 0 || clip_box.height <= 0) {
@ -606,7 +475,6 @@ void client_apply_clip(Client *c) {
scale_data.height = clip_box.height; scale_data.height = clip_box.height;
scale_data.width_scale = (float)scale_data.width / acutal_surface_width; scale_data.width_scale = (float)scale_data.width / acutal_surface_width;
scale_data.height_scale = (float)scale_data.height / acutal_surface_height; scale_data.height_scale = (float)scale_data.height / acutal_surface_height;
scale_data.corner_location = current_corner_location;
scale_data.percent = percent; scale_data.percent = percent;
scale_data.opacity = opacity; scale_data.opacity = opacity;
buffer_set_effect(c, scale_data); buffer_set_effect(c, scale_data);
@ -938,7 +806,6 @@ void resize(Client *c, struct wlr_box geo, int interact) {
c->geom; c->geom;
wlr_scene_node_set_position(&c->scene->node, c->geom.x, c->geom.y); wlr_scene_node_set_position(&c->scene->node, c->geom.x, c->geom.y);
client_draw_shadow(c);
apply_border(c); apply_border(c);
client_get_clip(c, &clip); client_get_clip(c, &clip);
wlr_scene_subsurface_tree_set_clip(&c->scene_surface->node, &clip); wlr_scene_subsurface_tree_set_clip(&c->scene_surface->node, &clip);

55
src/animation/common.h
View file

@ -99,16 +99,15 @@ static bool scene_node_snapshot(struct wlr_scene_node *node, int lx, int ly,
struct wlr_scene_node *snapshot_node = NULL; struct wlr_scene_node *snapshot_node = NULL;
switch (node->type) { switch (node->type) {
case WLR_SCENE_NODE_TREE: { case WLR_SCENE_NODE_TREE:;
struct wlr_scene_tree *scene_tree = wlr_scene_tree_from_node(node); struct wlr_scene_tree *scene_tree = wlr_scene_tree_from_node(node);
struct wlr_scene_node *child; struct wlr_scene_node *child;
wl_list_for_each(child, &scene_tree->children, link) { wl_list_for_each(child, &scene_tree->children, link) {
scene_node_snapshot(child, lx, ly, snapshot_tree); scene_node_snapshot(child, lx, ly, snapshot_tree);
} }
break; break;
} case WLR_SCENE_NODE_RECT:;
case WLR_SCENE_NODE_RECT: {
struct wlr_scene_rect *scene_rect = wlr_scene_rect_from_node(node); struct wlr_scene_rect *scene_rect = wlr_scene_rect_from_node(node);
struct wlr_scene_rect *snapshot_rect = struct wlr_scene_rect *snapshot_rect =
@ -118,20 +117,10 @@ static bool scene_node_snapshot(struct wlr_scene_node *node, int lx, int ly,
if (snapshot_rect == NULL) { if (snapshot_rect == NULL) {
return false; return false;
} }
wlr_scene_rect_set_clipped_region(scene_rect,
snapshot_rect->clipped_region);
wlr_scene_rect_set_backdrop_blur(scene_rect, false);
// wlr_scene_rect_set_backdrop_blur_optimized(
// scene_rect, snapshot_rect->backdrop_blur_optimized);
wlr_scene_rect_set_corner_radius(
scene_rect, snapshot_rect->corner_radius, snapshot_rect->corners);
wlr_scene_rect_set_color(scene_rect, snapshot_rect->color);
snapshot_node = &snapshot_rect->node; snapshot_node = &snapshot_rect->node;
break; break;
} case WLR_SCENE_NODE_BUFFER:;
case WLR_SCENE_NODE_BUFFER: {
struct wlr_scene_buffer *scene_buffer = struct wlr_scene_buffer *scene_buffer =
wlr_scene_buffer_from_node(node); wlr_scene_buffer_from_node(node);
@ -156,15 +145,6 @@ static bool scene_node_snapshot(struct wlr_scene_node *node, int lx, int ly,
// Effects // Effects
wlr_scene_buffer_set_opacity(snapshot_buffer, scene_buffer->opacity); wlr_scene_buffer_set_opacity(snapshot_buffer, scene_buffer->opacity);
wlr_scene_buffer_set_corner_radius(snapshot_buffer,
scene_buffer->corner_radius,
scene_buffer->corners);
// wlr_scene_buffer_set_backdrop_blur_optimized(
// snapshot_buffer, scene_buffer->backdrop_blur_optimized);
// wlr_scene_buffer_set_backdrop_blur_ignore_transparent(
// snapshot_buffer, scene_buffer->backdrop_blur_ignore_transparent);
wlr_scene_buffer_set_backdrop_blur(snapshot_buffer, false);
snapshot_buffer->node.data = scene_buffer->node.data; snapshot_buffer->node.data = scene_buffer->node.data;
@ -178,31 +158,6 @@ static bool scene_node_snapshot(struct wlr_scene_node *node, int lx, int ly,
} }
break; break;
} }
case WLR_SCENE_NODE_SHADOW: {
struct wlr_scene_shadow *scene_shadow =
wlr_scene_shadow_from_node(node);
struct wlr_scene_shadow *snapshot_shadow = wlr_scene_shadow_create(
snapshot_tree, scene_shadow->width, scene_shadow->height,
scene_shadow->corner_radius, scene_shadow->blur_sigma,
scene_shadow->color);
if (snapshot_shadow == NULL) {
return false;
}
snapshot_node = &snapshot_shadow->node;
wlr_scene_shadow_set_clipped_region(snapshot_shadow,
scene_shadow->clipped_region);
snapshot_shadow->node.data = scene_shadow->node.data;
wlr_scene_node_set_enabled(&snapshot_shadow->node, false);
break;
}
case WLR_SCENE_NODE_OPTIMIZED_BLUR:
return true;
}
if (snapshot_node != NULL) { if (snapshot_node != NULL) {
wlr_scene_node_set_position(snapshot_node, lx, ly); wlr_scene_node_set_position(snapshot_node, lx, ly);

51
src/animation/layer.h
View file

@ -145,55 +145,6 @@ void set_layer_open_animaiton(LayerSurface *l, struct wlr_box geo) {
} }
} }
void layer_draw_shadow(LayerSurface *l) {
if (!l->mapped || !l->shadow)
return;
if (!shadows || !layer_shadows || l->noshadow) {
wlr_scene_shadow_set_size(l->shadow, 0, 0);
return;
}
uint32_t width, height;
layer_actual_size(l, &width, &height);
uint32_t delta = shadows_size;
/* we calculate where to clip the shadow */
struct wlr_box layer_box = {
.x = 0,
.y = 0,
.width = width,
.height = height,
};
struct wlr_box shadow_box = {
.x = shadows_position_x,
.y = shadows_position_y,
.width = width + 2 * delta,
.height = height + 2 * delta,
};
struct wlr_box intersection_box;
wlr_box_intersection(&intersection_box, &layer_box, &shadow_box);
/* clipped region takes shadow relative coords, so we translate everything
* by its position */
intersection_box.x -= shadows_position_x;
intersection_box.y -= shadows_position_y;
struct clipped_region clipped_region = {
.area = intersection_box,
.corner_radius = border_radius,
.corners = border_radius_location_default,
};
wlr_scene_node_set_position(&l->shadow->node, shadow_box.x, shadow_box.y);
wlr_scene_shadow_set_size(l->shadow, shadow_box.width, shadow_box.height);
wlr_scene_shadow_set_clipped_region(l->shadow, clipped_region);
}
void fadeout_layer_animation_next_tick(LayerSurface *l) { void fadeout_layer_animation_next_tick(LayerSurface *l) {
if (!l) if (!l)
return; return;
@ -404,9 +355,7 @@ bool layer_draw_frame(LayerSurface *l) {
if (animations && layer_animations && l->animation.running && !l->noanim) { if (animations && layer_animations && l->animation.running && !l->noanim) {
layer_animation_next_tick(l); layer_animation_next_tick(l);
layer_draw_shadow(l);
} else { } else {
layer_draw_shadow(l);
l->need_output_flush = false; l->need_output_flush = false;
} }
return true; return true;

4
src/client/client.h
View file

@ -308,7 +308,9 @@ static inline void client_send_close(Client *c) {
static inline void client_set_border_color(Client *c, static inline void client_set_border_color(Client *c,
const float color[static 4]) { const float color[static 4]) {
wlr_scene_rect_set_color(c->border, color); int i;
for (i = 0; i < 4; i++)
wlr_scene_rect_set_color(c->border[i], color);
} }
static inline void client_set_fullscreen(Client *c, int fullscreen) { static inline void client_set_fullscreen(Client *c, int fullscreen) {

132
src/config/parse_config.h
View file

@ -125,9 +125,7 @@ typedef struct {
typedef struct { typedef struct {
char *layer_name; // 布局名称 char *layer_name; // 布局名称
int noblur;
int noanim; int noanim;
int noshadow;
} ConfigLayerRule; } ConfigLayerRule;
typedef struct { typedef struct {
@ -158,7 +156,6 @@ typedef struct {
int focus_cross_monitor; int focus_cross_monitor;
int focus_cross_tag; int focus_cross_tag;
int no_border_when_single; int no_border_when_single;
int no_radius_when_single;
int snap_distance; int snap_distance;
int enable_floating_snap; int enable_floating_snap;
int drag_tile_to_tile; int drag_tile_to_tile;
@ -211,20 +208,6 @@ typedef struct {
unsigned int send_events_mode; unsigned int send_events_mode;
unsigned int button_map; unsigned int button_map;
int blur;
int blur_layer;
int blur_optimized;
int border_radius;
struct blur_data blur_params;
int shadows;
int shadow_only_floating;
int layer_shadows;
unsigned int shadows_size;
float shadows_blur;
int shadows_position_x;
int shadows_position_y;
float shadowscolor[4];
int smartgaps; int smartgaps;
unsigned int gappih; unsigned int gappih;
unsigned int gappiv; unsigned int gappiv;
@ -919,40 +902,6 @@ void parse_config_line(Config *config, const char *line) {
config->focus_cross_tag = atoi(value); config->focus_cross_tag = atoi(value);
} else if (strcmp(key, "focus_cross_tag") == 0) { } else if (strcmp(key, "focus_cross_tag") == 0) {
config->focus_cross_tag = atoi(value); config->focus_cross_tag = atoi(value);
} else if (strcmp(key, "blur") == 0) {
config->blur = atoi(value);
} else if (strcmp(key, "blur_layer") == 0) {
config->blur_layer = atoi(value);
} else if (strcmp(key, "blur_optimized") == 0) {
config->blur_optimized = atoi(value);
} else if (strcmp(key, "border_radius") == 0) {
config->border_radius = atoi(value);
} else if (strcmp(key, "blur_params_num_passes") == 0) {
config->blur_params.num_passes = atoi(value);
} else if (strcmp(key, "blur_params_radius") == 0) {
config->blur_params.radius = atoi(value);
} else if (strcmp(key, "blur_params_noise") == 0) {
config->blur_params.noise = atof(value);
} else if (strcmp(key, "blur_params_brightness") == 0) {
config->blur_params.brightness = atof(value);
} else if (strcmp(key, "blur_params_contrast") == 0) {
config->blur_params.contrast = atof(value);
} else if (strcmp(key, "blur_params_saturation") == 0) {
config->blur_params.saturation = atof(value);
} else if (strcmp(key, "shadows") == 0) {
config->shadows = atoi(value);
} else if (strcmp(key, "shadow_only_floating") == 0) {
config->shadow_only_floating = atoi(value);
} else if (strcmp(key, "layer_shadows") == 0) {
config->layer_shadows = atoi(value);
} else if (strcmp(key, "shadows_size") == 0) {
config->shadows_size = atoi(value);
} else if (strcmp(key, "shadows_blur") == 0) {
config->shadows_blur = atof(value);
} else if (strcmp(key, "shadows_position_x") == 0) {
config->shadows_position_x = atoi(value);
} else if (strcmp(key, "shadows_position_y") == 0) {
config->shadows_position_y = atoi(value);
} else if (strcmp(key, "single_scratchpad") == 0) { } else if (strcmp(key, "single_scratchpad") == 0) {
config->single_scratchpad = atoi(value); config->single_scratchpad = atoi(value);
} else if (strcmp(key, "xwayland_persistence") == 0) { } else if (strcmp(key, "xwayland_persistence") == 0) {
@ -961,8 +910,6 @@ void parse_config_line(Config *config, const char *line) {
config->syncobj_enable = atoi(value); config->syncobj_enable = atoi(value);
} else if (strcmp(key, "no_border_when_single") == 0) { } else if (strcmp(key, "no_border_when_single") == 0) {
config->no_border_when_single = atoi(value); config->no_border_when_single = atoi(value);
} else if (strcmp(key, "no_radius_when_single") == 0) {
config->no_radius_when_single = atoi(value);
} else if (strcmp(key, "snap_distance") == 0) { } else if (strcmp(key, "snap_distance") == 0) {
config->snap_distance = atoi(value); config->snap_distance = atoi(value);
} else if (strcmp(key, "enable_floating_snap") == 0) { } else if (strcmp(key, "enable_floating_snap") == 0) {
@ -1210,13 +1157,6 @@ void parse_config_line(Config *config, const char *line) {
convert_hex_to_rgba(config->rootcolor, color); convert_hex_to_rgba(config->rootcolor, color);
} }
} else if (strcmp(key, "shadowscolor") == 0) {
long int color = parse_color(value);
if (color == -1) {
fprintf(stderr, "Error: Invalid shadowscolor format: %s\n", value);
} else {
convert_hex_to_rgba(config->shadowscolor, color);
}
} else if (strcmp(key, "bordercolor") == 0) { } else if (strcmp(key, "bordercolor") == 0) {
long int color = parse_color(value); long int color = parse_color(value);
if (color == -1) { if (color == -1) {
@ -1333,9 +1273,7 @@ void parse_config_line(Config *config, const char *line) {
// 设置默认值 // 设置默认值
rule->layer_name = NULL; rule->layer_name = NULL;
rule->noblur = 0;
rule->noanim = 0; rule->noanim = 0;
rule->noshadow = 0;
char *token = strtok(value, ","); char *token = strtok(value, ",");
while (token != NULL) { while (token != NULL) {
@ -1350,12 +1288,8 @@ void parse_config_line(Config *config, const char *line) {
if (strcmp(key, "layer_name") == 0) { if (strcmp(key, "layer_name") == 0) {
rule->layer_name = strdup(val); rule->layer_name = strdup(val);
} else if (strcmp(key, "noblur") == 0) {
rule->noblur = CLAMP_INT(atoi(val), 0, 1);
} else if (strcmp(key, "noanim") == 0) { } else if (strcmp(key, "noanim") == 0) {
rule->noanim = CLAMP_INT(atoi(val), 0, 1); rule->noanim = CLAMP_INT(atoi(val), 0, 1);
} else if (strcmp(key, "noshadow") == 0) {
rule->noshadow = CLAMP_INT(atoi(val), 0, 1);
} }
} }
token = strtok(NULL, ","); token = strtok(NULL, ",");
@ -2166,7 +2100,6 @@ void override_config(void) {
snap_distance = CLAMP_INT(config.snap_distance, 0, 99999); snap_distance = CLAMP_INT(config.snap_distance, 0, 99999);
cursor_size = CLAMP_INT(config.cursor_size, 4, 512); cursor_size = CLAMP_INT(config.cursor_size, 4, 512);
no_border_when_single = CLAMP_INT(config.no_border_when_single, 0, 1); no_border_when_single = CLAMP_INT(config.no_border_when_single, 0, 1);
no_radius_when_single = CLAMP_INT(config.no_radius_when_single, 0, 1);
cursor_hide_timeout = cursor_hide_timeout =
CLAMP_INT(config.cursor_hide_timeout, 0, 36000); // 0-10小时 CLAMP_INT(config.cursor_hide_timeout, 0, 36000); // 0-10小时
drag_tile_to_tile = CLAMP_INT(config.drag_tile_to_tile, 0, 1); drag_tile_to_tile = CLAMP_INT(config.drag_tile_to_tile, 0, 1);
@ -2210,26 +2143,8 @@ void override_config(void) {
borderpx = CLAMP_INT(config.borderpx, 0, 200); borderpx = CLAMP_INT(config.borderpx, 0, 200);
smartgaps = CLAMP_INT(config.smartgaps, 0, 1); smartgaps = CLAMP_INT(config.smartgaps, 0, 1);
blur = CLAMP_INT(config.blur, 0, 1);
blur_layer = CLAMP_INT(config.blur_layer, 0, 1);
blur_optimized = CLAMP_INT(config.blur_optimized, 0, 1);
border_radius = CLAMP_INT(config.border_radius, 0, 100);
blur_params.num_passes = CLAMP_INT(config.blur_params.num_passes, 0, 10);
blur_params.radius = CLAMP_INT(config.blur_params.radius, 0, 100);
blur_params.noise = CLAMP_FLOAT(config.blur_params.noise, 0, 1);
blur_params.brightness = CLAMP_FLOAT(config.blur_params.brightness, 0, 1);
blur_params.contrast = CLAMP_FLOAT(config.blur_params.contrast, 0, 1);
blur_params.saturation = CLAMP_FLOAT(config.blur_params.saturation, 0, 1);
shadows = CLAMP_INT(config.shadows, 0, 1);
shadow_only_floating = CLAMP_INT(config.shadow_only_floating, 0, 1);
layer_shadows = CLAMP_INT(config.layer_shadows, 0, 1);
shadows_size = CLAMP_INT(config.shadows_size, 0, 100);
shadows_blur = CLAMP_INT(config.shadows_blur, 0, 100);
shadows_position_x = CLAMP_INT(config.shadows_position_x, -1000, 1000);
shadows_position_y = CLAMP_INT(config.shadows_position_y, -1000, 1000);
focused_opacity = CLAMP_FLOAT(config.focused_opacity, 0.0f, 1.0f); focused_opacity = CLAMP_FLOAT(config.focused_opacity, 0.0f, 1.0f);
unfocused_opacity = CLAMP_FLOAT(config.unfocused_opacity, 0.0f, 1.0f); unfocused_opacity = CLAMP_FLOAT(config.unfocused_opacity, 0.0f, 1.0f);
memcpy(shadowscolor, config.shadowscolor, sizeof(shadowscolor));
// 复制颜色数组 // 复制颜色数组
memcpy(rootcolor, config.rootcolor, sizeof(rootcolor)); memcpy(rootcolor, config.rootcolor, sizeof(rootcolor));
@ -2311,7 +2226,6 @@ void set_value_default() {
config.xwayland_persistence = xwayland_persistence; config.xwayland_persistence = xwayland_persistence;
config.syncobj_enable = syncobj_enable; config.syncobj_enable = syncobj_enable;
config.no_border_when_single = no_border_when_single; config.no_border_when_single = no_border_when_single;
config.no_radius_when_single = no_radius_when_single;
config.snap_distance = snap_distance; config.snap_distance = snap_distance;
config.drag_tile_to_tile = drag_tile_to_tile; config.drag_tile_to_tile = drag_tile_to_tile;
config.enable_floating_snap = enable_floating_snap; config.enable_floating_snap = enable_floating_snap;
@ -2351,26 +2265,8 @@ void set_value_default() {
config.send_events_mode = send_events_mode; config.send_events_mode = send_events_mode;
config.button_map = button_map; config.button_map = button_map;
config.blur = blur;
config.blur_layer = blur_layer;
config.blur_optimized = blur_optimized;
config.border_radius = border_radius;
config.blur_params.num_passes = blur_params_num_passes;
config.blur_params.radius = blur_params_radius;
config.blur_params.noise = blur_params_noise;
config.blur_params.brightness = blur_params_brightness;
config.blur_params.contrast = blur_params_contrast;
config.blur_params.saturation = blur_params_saturation;
config.shadows = shadows;
config.shadow_only_floating = shadow_only_floating;
config.layer_shadows = layer_shadows;
config.shadows_size = shadows_size;
config.shadows_blur = shadows_blur;
config.shadows_position_x = shadows_position_x;
config.shadows_position_y = shadows_position_y;
config.focused_opacity = focused_opacity; config.focused_opacity = focused_opacity;
config.unfocused_opacity = unfocused_opacity; config.unfocused_opacity = unfocused_opacity;
memcpy(config.shadowscolor, shadowscolor, sizeof(shadowscolor));
memcpy(config.animation_curve_move, animation_curve_move, memcpy(config.animation_curve_move, animation_curve_move,
sizeof(animation_curve_move)); sizeof(animation_curve_move));
@ -2482,33 +2378,6 @@ void parse_config(void) {
override_config(); override_config();
} }
void reset_blur_params(void) {
if (blur) {
Monitor *m;
wl_list_for_each(m, &mons, link) {
if (m->blur != NULL) {
wlr_scene_node_destroy(&m->blur->node);
}
m->blur = wlr_scene_optimized_blur_create(&scene->tree, 0, 0);
wlr_scene_node_reparent(&m->blur->node, layers[LyrBlur]);
wlr_scene_optimized_blur_set_size(m->blur, m->m.width, m->m.height);
wlr_scene_set_blur_data(
scene, blur_params.num_passes, blur_params.radius,
blur_params.noise, blur_params.brightness, blur_params.contrast,
blur_params.saturation);
}
} else {
Monitor *m;
wl_list_for_each(m, &mons, link) {
if (m->blur) {
wlr_scene_node_destroy(&m->blur->node);
m->blur = NULL;
}
}
}
}
void reload_config(const Arg *arg) { void reload_config(const Arg *arg) {
Client *c; Client *c;
Monitor *m; Monitor *m;
@ -2519,7 +2388,6 @@ void reload_config(const Arg *arg) {
init_baked_points(); init_baked_points();
handlecursoractivity(); handlecursoractivity();
reset_keyboard_layout(); reset_keyboard_layout();
reset_blur_params();
run_exec(); run_exec();
// reset border width when config change // reset border width when config change

25
src/config/preset.h
View file

@ -175,28 +175,3 @@ static const char *tags[] = {
float focused_opacity = 1.0; float focused_opacity = 1.0;
float unfocused_opacity = 1.0; float unfocused_opacity = 1.0;
int border_radius = 0;
int border_radius_location_default = CORNER_LOCATION_ALL;
int blur = 0;
int blur_layer = 0;
int blur_optimized = 1;
struct blur_data blur_params;
int blur_params_num_passes = 1;
int blur_params_radius = 5;
float blur_params_noise = 0.02;
float blur_params_brightness = 0.9;
float blur_params_contrast = 0.9;
float blur_params_saturation = 1.2;
int shadows = 0;
int shadow_only_floating = 1;
int layer_shadows = 0;
unsigned int shadows_size = 10;
double shadows_blur = 15;
int shadows_position_x = 0;
int shadows_position_y = 0;
float shadowscolor[] = COLOR(0x000000ff);
;

152
src/maomao.c
View file

@ -7,11 +7,6 @@
#include <libinput.h> #include <libinput.h>
#include <limits.h> #include <limits.h>
#include <linux/input-event-codes.h> #include <linux/input-event-codes.h>
#include <scenefx/render/fx_renderer/fx_renderer.h>
#include <scenefx/types/fx/blur_data.h>
#include <scenefx/types/fx/clipped_region.h>
#include <scenefx/types/fx/corner_location.h>
#include <scenefx/types/wlr_scene.h>
#include <signal.h> #include <signal.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
@ -61,6 +56,7 @@
#include <wlr/types/wlr_primary_selection.h> #include <wlr/types/wlr_primary_selection.h>
#include <wlr/types/wlr_primary_selection_v1.h> #include <wlr/types/wlr_primary_selection_v1.h>
#include <wlr/types/wlr_relative_pointer_v1.h> #include <wlr/types/wlr_relative_pointer_v1.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/types/wlr_screencopy_v1.h> #include <wlr/types/wlr_screencopy_v1.h>
#include <wlr/types/wlr_seat.h> #include <wlr/types/wlr_seat.h>
#include <wlr/types/wlr_server_decoration.h> #include <wlr/types/wlr_server_decoration.h>
@ -132,7 +128,6 @@ enum { XDGShell, LayerShell, X11 }; /* client types */
enum { AxisUp, AxisDown, AxisLeft, AxisRight }; // 滚轮滚动的方向 enum { AxisUp, AxisDown, AxisLeft, AxisRight }; // 滚轮滚动的方向
enum { enum {
LyrBg, LyrBg,
LyrBlur,
LyrBottom, LyrBottom,
LyrTile, LyrTile,
LyrFloat, LyrFloat,
@ -217,7 +212,6 @@ typedef struct {
int height; int height;
double percent; double percent;
float opacity; float opacity;
enum corner_location corner_location;
bool should_scale; bool should_scale;
} animationScale; } animationScale;
@ -229,8 +223,7 @@ struct Client {
current; /* layout-relative, includes border */ current; /* layout-relative, includes border */
Monitor *mon; Monitor *mon;
struct wlr_scene_tree *scene; struct wlr_scene_tree *scene;
struct wlr_scene_rect *border; /* top, bottom, left, right */ struct wlr_scene_rect *border[4]; /* top, bottom, left, right */
struct wlr_scene_shadow *shadow;
struct wlr_scene_tree *scene_surface; struct wlr_scene_tree *scene_surface;
struct wl_list link; struct wl_list link;
struct wl_list flink; struct wl_list flink;
@ -356,7 +349,6 @@ typedef struct {
Monitor *mon; Monitor *mon;
struct wlr_scene_tree *scene; struct wlr_scene_tree *scene;
struct wlr_scene_tree *popups; struct wlr_scene_tree *popups;
struct wlr_scene_shadow *shadow;
struct wlr_scene_layer_surface_v1 *scene_layer; struct wlr_scene_layer_surface_v1 *scene_layer;
struct wl_list link; struct wl_list link;
struct wl_list fadeout_link; struct wl_list fadeout_link;
@ -370,9 +362,7 @@ typedef struct {
struct dwl_animation animation; struct dwl_animation animation;
bool dirty; bool dirty;
int noblur;
int noanim; int noanim;
int noshadow;
bool need_output_flush; bool need_output_flush;
} LayerSurface; } LayerSurface;
@ -413,7 +403,6 @@ struct Monitor {
int asleep; int asleep;
unsigned int visible_clients; unsigned int visible_clients;
unsigned int visible_tiling_clients; unsigned int visible_tiling_clients;
struct wlr_scene_optimized_blur *blur;
char last_surface_ws_name[256]; char last_surface_ws_name[256];
}; };
@ -655,7 +644,6 @@ static double find_animation_curve_at(double t, int type);
static void apply_opacity_to_rect_nodes(Client *c, struct wlr_scene_node *node, static void apply_opacity_to_rect_nodes(Client *c, struct wlr_scene_node *node,
double animation_passed); double animation_passed);
static enum corner_location set_client_corner_location(Client *c);
static double output_frame_duration_ms(); static double output_frame_duration_ms();
static struct wlr_scene_tree * static struct wlr_scene_tree *
wlr_scene_tree_snapshot(struct wlr_scene_node *node, wlr_scene_tree_snapshot(struct wlr_scene_node *node,
@ -1151,7 +1139,7 @@ void gpureset(struct wl_listener *listener, void *data) {
wlr_log(WLR_DEBUG, "gpu reset"); wlr_log(WLR_DEBUG, "gpu reset");
if (!(drw = fx_renderer_create(backend))) if (!(drw = wlr_renderer_autocreate(backend)))
die("couldn't recreate renderer"); die("couldn't recreate renderer");
if (!(alloc = wlr_allocator_autocreate(backend, drw))) if (!(alloc = wlr_allocator_autocreate(backend, drw)))
@ -2430,10 +2418,6 @@ void cleanupmon(struct wl_listener *listener, void *data) {
wlr_scene_output_destroy(m->scene_output); wlr_scene_output_destroy(m->scene_output);
closemon(m); closemon(m);
if (m->blur) {
wlr_scene_node_destroy(&m->blur->node);
m->blur = NULL;
}
free(m); free(m);
} }
@ -2474,23 +2458,6 @@ void closemon(Monitor *m) {
} }
} }
static void iter_layer_scene_buffers(struct wlr_scene_buffer *buffer, int sx,
int sy, void *user_data) {
struct wlr_scene_surface *scene_surface =
wlr_scene_surface_try_from_buffer(buffer);
if (!scene_surface) {
return;
}
wlr_scene_buffer_set_backdrop_blur(buffer, true);
wlr_scene_buffer_set_backdrop_blur_ignore_transparent(buffer, true);
if (blur_optimized) {
wlr_scene_buffer_set_backdrop_blur_optimized(buffer, true);
} else {
wlr_scene_buffer_set_backdrop_blur_optimized(buffer, false);
}
}
void maplayersurfacenotify(struct wl_listener *listener, void *data) { void maplayersurfacenotify(struct wl_listener *listener, void *data) {
LayerSurface *l = wl_container_of(listener, l, map); LayerSurface *l = wl_container_of(listener, l, map);
struct wlr_layer_surface_v1 *layer_surface = l->layer_surface; struct wlr_layer_surface_v1 *layer_surface = l->layer_surface;
@ -2510,8 +2477,6 @@ void maplayersurfacenotify(struct wl_listener *listener, void *data) {
l->noanim = 0; l->noanim = 0;
l->dirty = false; l->dirty = false;
l->noblur = 0;
l->shadow = NULL;
l->need_output_flush = true; l->need_output_flush = true;
// 应用layer规则 // 应用layer规则
@ -2520,27 +2485,11 @@ void maplayersurfacenotify(struct wl_listener *listener, void *data) {
break; break;
if (strcmp(config.layer_rules[ji].layer_name, if (strcmp(config.layer_rules[ji].layer_name,
l->layer_surface->namespace) == 0) { l->layer_surface->namespace) == 0) {
if (config.layer_rules[ji].noblur > 0) {
l->noblur = 1;
}
if (config.layer_rules[ji].noanim > 0) { if (config.layer_rules[ji].noanim > 0) {
l->noanim = 1; l->noanim = 1;
} }
if (config.layer_rules[ji].noshadow > 0) {
l->noshadow = 1;
} }
} }
}
// 初始化阴影
if (layer_surface->current.exclusive_zone == 0 &&
layer_surface->current.layer != ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM &&
layer_surface->current.layer != ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND) {
l->shadow = wlr_scene_shadow_create(l->scene, 0, 0, border_radius,
shadows_blur, shadowscolor);
wlr_scene_node_lower_to_bottom(&l->shadow->node);
wlr_scene_node_set_enabled(&l->shadow->node, true);
}
// 初始化动画 // 初始化动画
if (animations && layer_animations && !l->noanim) { if (animations && layer_animations && !l->noanim) {
@ -2597,29 +2546,6 @@ void commitlayersurfacenotify(struct wl_listener *listener, void *data) {
layer_set_pending_state(l); layer_set_pending_state(l);
} }
if (blur && blur_layer) {
// 设置非背景layer模糊
if (!l->noblur &&
layer_surface->current.layer != ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM &&
layer_surface->current.layer !=
ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND) {
wlr_scene_node_for_each_buffer(&l->scene->node,
iter_layer_scene_buffers, l);
}
}
if (blur) {
// 如果背景层发生变化,标记优化的模糊背景缓存需要更新
if (layer_surface->current.layer ==
ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND) {
if (l->mon) {
wlr_scene_optimized_blur_mark_dirty(l->mon->blur);
}
}
}
if (layer_surface == exclusive_focus && if (layer_surface == exclusive_focus &&
layer_surface->current.keyboard_interactive != layer_surface->current.keyboard_interactive !=
ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE) ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE)
@ -3002,14 +2928,6 @@ void createmon(struct wl_listener *listener, void *data) {
wlr_output_layout_add_auto(output_layout, wlr_output); wlr_output_layout_add_auto(output_layout, wlr_output);
else else
wlr_output_layout_add(output_layout, wlr_output, m->m.x, m->m.y); wlr_output_layout_add(output_layout, wlr_output, m->m.x, m->m.y);
if (blur) {
m->blur = wlr_scene_optimized_blur_create(&scene->tree, 0, 0);
wlr_scene_node_set_position(&m->blur->node, m->m.x, m->m.y);
wlr_scene_node_reparent(&m->blur->node, layers[LyrBlur]);
wlr_scene_optimized_blur_set_size(m->blur, m->m.width, m->m.height);
// wlr_scene_node_set_enabled(&m->blur->node, 1);
}
} }
void // fix for 0.5 void // fix for 0.5
@ -3821,34 +3739,6 @@ void locksession(struct wl_listener *listener, void *data) {
wlr_session_lock_v1_send_locked(session_lock); wlr_session_lock_v1_send_locked(session_lock);
} }
static void iter_xdg_scene_buffers(struct wlr_scene_buffer *buffer, int sx,
int sy, void *user_data) {
Client *c = user_data;
struct wlr_scene_surface *scene_surface =
wlr_scene_surface_try_from_buffer(buffer);
if (!scene_surface) {
return;
}
struct wlr_surface *surface = scene_surface->surface;
/* we dont blur subsurfaces */
if (wlr_subsurface_try_from_wlr_surface(surface) != NULL)
return;
if (blur && c) {
wlr_scene_buffer_set_backdrop_blur(buffer, true);
wlr_scene_buffer_set_backdrop_blur_ignore_transparent(buffer, true);
if (blur_optimized) {
wlr_scene_buffer_set_backdrop_blur_optimized(buffer, true);
} else {
wlr_scene_buffer_set_backdrop_blur_optimized(buffer, false);
}
} else {
wlr_scene_buffer_set_backdrop_blur(buffer, false);
}
}
void init_client_properties(Client *c) { void init_client_properties(Client *c) {
c->ismaxmizescreen = 0; c->ismaxmizescreen = 0;
c->isfullscreen = 0; c->isfullscreen = 0;
@ -3884,6 +3774,7 @@ mapnotify(struct wl_listener *listener, void *data) {
/* Called when the surface is mapped, or ready to display on-screen. */ /* Called when the surface is mapped, or ready to display on-screen. */
Client *p = NULL; Client *p = NULL;
Client *c = wl_container_of(listener, c, map); Client *c = wl_container_of(listener, c, map);
int i;
/* Create scene tree for this client and its border */ /* Create scene tree for this client and its border */
c->scene = client_surface(c)->data = wlr_scene_tree_create(layers[LyrTile]); c->scene = client_surface(c)->data = wlr_scene_tree_create(layers[LyrTile]);
wlr_scene_node_set_enabled(&c->scene->node, c->type != XDGShell); wlr_scene_node_set_enabled(&c->scene->node, c->type != XDGShell);
@ -3931,22 +3822,11 @@ mapnotify(struct wl_listener *listener, void *data) {
return; return;
} }
c->border = wlr_scene_rect_create(c->scene, 0, 0, for (i = 0; i < 4; i++) {
c->isurgent ? urgentcolor : bordercolor); c->border[i] = wlr_scene_rect_create(
wlr_scene_node_lower_to_bottom(&c->border->node); c->scene, 0, 0, c->isurgent ? urgentcolor : bordercolor);
wlr_scene_node_set_position(&c->border->node, 0, 0); c->border[i]->node.data = c;
wlr_scene_rect_set_corner_radius(c->border, border_radius, }
border_radius_location_default);
wlr_scene_node_set_enabled(&c->border->node, true);
c->shadow = wlr_scene_shadow_create(c->scene, 0, 0, border_radius,
shadows_blur, shadowscolor);
wlr_scene_node_lower_to_bottom(&c->shadow->node);
wlr_scene_node_set_enabled(&c->shadow->node, true);
wlr_scene_node_for_each_buffer(&c->scene_surface->node,
iter_xdg_scene_buffers, c);
/* Initialize client geometry with room for border */ /* Initialize client geometry with room for border */
client_set_tiled(c, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | client_set_tiled(c, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT |
@ -5345,8 +5225,8 @@ void setup(void) {
wlr_scene_node_place_below(&drag_icon->node, &layers[LyrBlock]->node); wlr_scene_node_place_below(&drag_icon->node, &layers[LyrBlock]->node);
/* Create a renderer with the default implementation */ /* Create a renderer with the default implementation */
if (!(drw = fx_renderer_create(backend))) if (!(drw = wlr_renderer_autocreate(backend)))
die("couldn't create renderer"); die("couldn't recreate renderer");
wl_signal_add(&drw->events.lost, &gpu_reset); wl_signal_add(&drw->events.lost, &gpu_reset);
@ -5538,11 +5418,6 @@ void setup(void) {
wl_signal_add(&output_mgr->events.apply, &output_mgr_apply); wl_signal_add(&output_mgr->events.apply, &output_mgr_apply);
wl_signal_add(&output_mgr->events.test, &output_mgr_test); wl_signal_add(&output_mgr->events.test, &output_mgr_test);
// blur
wlr_scene_set_blur_data(scene, blur_params.num_passes, blur_params.radius,
blur_params.noise, blur_params.brightness,
blur_params.contrast, blur_params.saturation);
/* create text_input-, and input_method-protocol relevant globals */ /* create text_input-, and input_method-protocol relevant globals */
input_method_manager = wlr_input_method_manager_v2_create(dpy); input_method_manager = wlr_input_method_manager_v2_create(dpy);
text_input_manager = wlr_text_input_manager_v3_create(dpy); text_input_manager = wlr_text_input_manager_v3_create(dpy);
@ -6226,11 +6101,6 @@ void updatemons(struct wl_listener *listener, void *data) {
*/ */
wlr_scene_output_set_position(m->scene_output, m->m.x, m->m.y); wlr_scene_output_set_position(m->scene_output, m->m.x, m->m.y);
if (blur && m->blur) {
wlr_scene_node_set_position(&m->blur->node, m->m.x, m->m.y);
wlr_scene_optimized_blur_set_size(m->blur, m->m.width, m->m.height);
}
if (m->lock_surface) { if (m->lock_surface) {
struct wlr_scene_tree *scene_tree = m->lock_surface->surface->data; struct wlr_scene_tree *scene_tree = m->lock_surface->surface->data;
wlr_scene_node_set_position(&scene_tree->node, m->m.x, m->m.y); wlr_scene_node_set_position(&scene_tree->node, m->m.x, m->m.y);