524 lines
19 KiB
Rust
524 lines
19 KiB
Rust
use smithay::desktop::Window;
|
|
|
|
use super::*;
|
|
|
|
pub(crate) fn animated_window_elements(
|
|
state: &mut Ferese,
|
|
renderer: &mut GlesRenderer,
|
|
output: &Output,
|
|
) -> Vec<AnimatedWindowRenderElement> {
|
|
output_elements(state, renderer, output, true)
|
|
}
|
|
|
|
pub(crate) fn frame_effect_metrics(_elements: &[AnimatedWindowRenderElement], _scale: f64) -> FrameEffectMetrics {
|
|
FrameEffectMetrics
|
|
}
|
|
|
|
pub(crate) fn output_elements(
|
|
state: &mut Ferese,
|
|
renderer: &mut GlesRenderer,
|
|
output: &Output,
|
|
include_cursor: bool,
|
|
) -> Vec<AnimatedWindowRenderElement> {
|
|
let frame = state.sample_frame(output, Duration::ZERO);
|
|
|
|
sampled_output_elements(state, renderer, output, include_cursor, &frame)
|
|
}
|
|
|
|
pub(crate) fn sampled_output_elements(
|
|
state: &mut Ferese,
|
|
renderer: &mut GlesRenderer,
|
|
output: &Output,
|
|
include_cursor: bool,
|
|
frame: &crate::state::FrameScene,
|
|
) -> Vec<AnimatedWindowRenderElement> {
|
|
scene_elements(state, renderer, output, include_cursor, frame, false)
|
|
}
|
|
|
|
pub(crate) fn capture_output_elements(
|
|
state: &mut Ferese,
|
|
renderer: &mut GlesRenderer,
|
|
output: &Output,
|
|
include_cursor: bool,
|
|
frame: &crate::state::FrameScene,
|
|
) -> Vec<AnimatedWindowRenderElement> {
|
|
// Blur textures and resize handoff snapshots must never be shared with
|
|
// display rendering. Only the capture scene can populate these caches.
|
|
std::mem::swap(&mut state.render, &mut state.capture_render);
|
|
let elements = scene_elements(state, renderer, output, include_cursor, frame, true);
|
|
std::mem::swap(&mut state.render, &mut state.capture_render);
|
|
elements
|
|
}
|
|
|
|
fn scene_elements(
|
|
state: &mut Ferese,
|
|
renderer: &mut GlesRenderer,
|
|
output: &Output,
|
|
include_cursor: bool,
|
|
frame: &crate::state::FrameScene,
|
|
capture: bool,
|
|
) -> Vec<AnimatedWindowRenderElement> {
|
|
if state.session_lock.active() {
|
|
let Some(geometry) = state.space.output_geometry(output) else {
|
|
return Vec::new();
|
|
};
|
|
let scale = output.current_scale().fractional_scale();
|
|
let background = state.session_lock.backgrounds.entry(output.clone()).or_insert_with(|| {
|
|
smithay::backend::renderer::element::solid::SolidColorBuffer::new(geometry.size, [0.0, 0.0, 0.0, 1.0])
|
|
});
|
|
background.resize(geometry.size);
|
|
let mut elements = Vec::new();
|
|
let opacity = state.session_lock.idle_opacity;
|
|
if opacity > 0.0 {
|
|
let overlay = state
|
|
.session_lock
|
|
.idle_overlays
|
|
.entry(output.clone())
|
|
.or_insert_with(|| {
|
|
smithay::backend::renderer::element::solid::SolidColorBuffer::new(
|
|
geometry.size,
|
|
[0.0, 0.0, 0.0, 1.0],
|
|
)
|
|
});
|
|
overlay.resize(geometry.size);
|
|
elements.push(
|
|
SolidColorRenderElement::from_buffer(overlay, (0, 0), scale, opacity, RenderElementKind::Unspecified)
|
|
.into(),
|
|
);
|
|
}
|
|
if let Some(surface) = state
|
|
.session_lock
|
|
.surfaces
|
|
.get(output)
|
|
.filter(|surface| surface.alive())
|
|
{
|
|
elements.extend(
|
|
render_elements_from_surface_tree::<GlesRenderer, WaylandSurfaceRenderElement<GlesRenderer>>(
|
|
renderer,
|
|
surface.wl_surface(),
|
|
(0, 0),
|
|
scale,
|
|
1.0,
|
|
RenderElementKind::Unspecified,
|
|
)
|
|
.into_iter()
|
|
.map(AnimatedWindowRenderElement::from),
|
|
);
|
|
}
|
|
elements.push(
|
|
SolidColorRenderElement::from_buffer(background, (0, 0), scale, 1.0, RenderElementKind::Unspecified).into(),
|
|
);
|
|
return elements;
|
|
}
|
|
let Some(output_geometry) = state.space.output_geometry(output) else {
|
|
return Vec::new();
|
|
};
|
|
let scale = output.current_scale().fractional_scale();
|
|
|
|
let protected_cursor = capture && state.capture_cursor_protected();
|
|
let mut elements = if include_cursor && !protected_cursor {
|
|
cursor_elements(state, renderer, output_geometry, scale)
|
|
} else {
|
|
Vec::new()
|
|
};
|
|
let upper_layers: &[Layer] = if state.output_has_fullscreen_for_frame(output, frame.overview.is_presenting()) {
|
|
&[Layer::Overlay]
|
|
} else {
|
|
&[Layer::Overlay, Layer::Top]
|
|
};
|
|
elements.extend(layer_elements(state, renderer, output, upper_layers));
|
|
if frame.overview.is_presenting() {
|
|
elements.extend(overview_strip_elements(
|
|
state,
|
|
renderer,
|
|
output,
|
|
output_geometry,
|
|
scale,
|
|
frame,
|
|
capture,
|
|
));
|
|
}
|
|
let prepare_window = |window: &Window| {
|
|
// Configure immediately, but present the frame/shadow only after
|
|
// the first buffer commit has settled the actual client geometry.
|
|
if (capture && state.capture_protected(window)) || !state.window_content_ready(window) {
|
|
return None;
|
|
}
|
|
let id = *state.windows.ids().get(window)?;
|
|
// Scrolling columns may sit outside their monitor's rectangle.
|
|
// They must not reappear on a neighboring output just because
|
|
// their global animated coordinates overlap it.
|
|
if !state.window_belongs_to_output(id, output) {
|
|
return None;
|
|
}
|
|
let sample = frame.windows.get(&id)?;
|
|
let visual = sample.presentation.bounds.current;
|
|
let presentation_alpha = sample.presentation.alpha();
|
|
let decoration_progress = sample.geometry.decorations.clamp(0.0, 1.0);
|
|
|
|
Some((
|
|
window.clone(),
|
|
id,
|
|
sample,
|
|
visual,
|
|
decoration_progress,
|
|
presentation_alpha,
|
|
))
|
|
};
|
|
let windows = if state.overview.is_active() {
|
|
state
|
|
.windows
|
|
.overview_windows()
|
|
.filter_map(prepare_window)
|
|
.collect::<Vec<_>>()
|
|
} else {
|
|
state
|
|
.space
|
|
.elements()
|
|
.rev()
|
|
.filter_map(prepare_window)
|
|
.collect::<Vec<_>>()
|
|
};
|
|
|
|
let mut closing = super::closing::grouped_elements(
|
|
state,
|
|
renderer,
|
|
output,
|
|
windows.iter().map(|(_, id, ..)| *id),
|
|
frame.delta,
|
|
);
|
|
for (window, id, sample, visual, decoration_progress, presentation_alpha) in windows {
|
|
if let Some(group) = closing.remove(&Some(id)) {
|
|
elements.extend(group);
|
|
}
|
|
let constrain = rounded_visual_rect(visual, output_geometry.loc);
|
|
let material_surface = window
|
|
.toplevel()
|
|
.map(|toplevel| toplevel.wl_surface())
|
|
.filter(|surface| {
|
|
crate::effects::surface_role(surface)
|
|
.is_some_and(|(role, _)| role == crate::effects::SemanticRole::Modal)
|
|
});
|
|
let window_radius = if material_surface.is_some() {
|
|
state.theme_settings.material_radius
|
|
} else {
|
|
state.theme_settings.window_radius
|
|
} * decoration_progress;
|
|
let shape = window_corner_shape(&window);
|
|
let corners = RoundedRect::new(visual, output_geometry.loc, scale, window_radius).with_shape(shape);
|
|
let corner_shape_changed = state.render.prepare_window_corners(id, shape);
|
|
let rounded_clip_program = corner_program(&mut state.render, renderer, shape);
|
|
// Only overview/close intentionally scale the complete application.
|
|
let scale_content = sample.presentation.scale_content;
|
|
let behavior = resize_content_behavior(scale_content);
|
|
|
|
let dim = sample.presentation.dim;
|
|
if let Some(overlay) = window_tint_element(
|
|
&mut state.render,
|
|
renderer,
|
|
id,
|
|
constrain,
|
|
corners,
|
|
[0.0, 0.0, 0.0, dim as f32 * presentation_alpha],
|
|
false,
|
|
output,
|
|
) {
|
|
// Front-to-back: dim the application and its border, not its shadow
|
|
// or other windows/layer surfaces. The overlay is input-transparent.
|
|
elements.push(overlay.into());
|
|
}
|
|
|
|
if let Some(programs) = rounded_clip_program.clone() {
|
|
let shadow_offset_y = state.theme_settings.shadow_offset_y;
|
|
let shadow_blur = state.theme_settings.shadow_blur;
|
|
let shadow_opacity = state.theme_settings.shadow_opacity;
|
|
let shadow_color = state.theme_settings.shadow_color.0;
|
|
let focus = sample.presentation.focus();
|
|
let border_width = state.theme_settings.border_width
|
|
+ (state.theme_settings.focus_ring_width - state.theme_settings.border_width) * focus;
|
|
let border_color = state.theme_settings.border_color.0;
|
|
let gradient = state.theme_settings.border_gradient;
|
|
|
|
if let Some(border) = window_border_element(
|
|
&mut state.render,
|
|
&state.theme_settings,
|
|
renderer,
|
|
id,
|
|
constrain,
|
|
corners,
|
|
scale,
|
|
border_width,
|
|
border_color,
|
|
gradient,
|
|
focus as f32,
|
|
presentation_alpha * decoration_progress as f32,
|
|
output,
|
|
&programs,
|
|
) {
|
|
elements.push(border.into());
|
|
}
|
|
let (offset_factor, blur_factor, opacity_factor) = sample.presentation.shadow_factors();
|
|
let shadow = window_shadow_element(
|
|
&mut state.render,
|
|
renderer,
|
|
id,
|
|
constrain,
|
|
corners,
|
|
scale,
|
|
shadow_offset_y * offset_factor,
|
|
shadow_blur * blur_factor,
|
|
shadow_opacity * opacity_factor * f64::from(presentation_alpha) * decoration_progress,
|
|
shadow_color,
|
|
output,
|
|
&programs,
|
|
);
|
|
if let Some(snapshot) = state.render.snapshot(&id)
|
|
&& snapshot.context == renderer.context_id().erased()
|
|
&& (snapshot.scale - scale).abs() < 0.001
|
|
&& let Some(element) = super::window_content::snapshot_element(
|
|
snapshot,
|
|
sample.presentation,
|
|
corners,
|
|
scale,
|
|
output,
|
|
&programs,
|
|
crate::presentation::handoff_alpha(snapshot.elapsed),
|
|
)
|
|
{
|
|
elements.push(element.into());
|
|
}
|
|
|
|
elements.extend(rounded_window_elements(
|
|
renderer,
|
|
&window,
|
|
corners,
|
|
scale,
|
|
presentation_alpha,
|
|
sample.geometry.presentation_changed || corner_shape_changed,
|
|
output,
|
|
programs.clone(),
|
|
behavior,
|
|
sample.presentation.native_size,
|
|
));
|
|
let source = window.geometry().size;
|
|
if material_surface.is_none()
|
|
&& !scale_content
|
|
&& (source.w < constrain.size.w || source.h < constrain.size.h)
|
|
{
|
|
let mut color = state.theme_settings.surface_base_color.0;
|
|
color[3] = presentation_alpha;
|
|
if let Some(fill) =
|
|
window_tint_element(&mut state.render, renderer, id, constrain, corners, color, true, output)
|
|
{
|
|
// Front-to-back: fill uncovered strips behind the native
|
|
// content instead of stretching it or exposing wallpaper.
|
|
elements.push(fill.into());
|
|
}
|
|
} else {
|
|
state.render.clear_tint(id, true);
|
|
}
|
|
if let Some(surface) = material_surface
|
|
&& let Some((background, _)) = material_element(
|
|
state,
|
|
renderer,
|
|
output,
|
|
surface,
|
|
MaterialSurface {
|
|
geometry: constrain,
|
|
corners,
|
|
index: 0,
|
|
capture_geometry: constrain,
|
|
alpha: presentation_alpha,
|
|
},
|
|
)
|
|
{
|
|
elements.push(background);
|
|
}
|
|
if let Some(shadow) = shadow {
|
|
elements.push(shadow.into());
|
|
}
|
|
} else {
|
|
elements.extend(constrain_space_element::<GlesRenderer, _, AnimatedWindowRenderElement>(
|
|
renderer,
|
|
&window,
|
|
constrain.loc,
|
|
presentation_alpha,
|
|
scale,
|
|
constrain,
|
|
ConstrainBehavior {
|
|
reference: ConstrainReference::Geometry,
|
|
behavior,
|
|
align: ConstrainAlign::TOP | ConstrainAlign::LEFT,
|
|
},
|
|
));
|
|
}
|
|
}
|
|
if let Some(group) = closing.remove(&None) {
|
|
elements.extend(group);
|
|
}
|
|
elements.extend(layer_elements(
|
|
state,
|
|
renderer,
|
|
output,
|
|
&[Layer::Bottom, Layer::Background],
|
|
));
|
|
state.prepare_theme_wallpaper(renderer, output);
|
|
let progress = state.theme_progress();
|
|
let wallpaper = state.wallpaper.element(renderer, output);
|
|
let has_wallpaper = wallpaper.is_some();
|
|
if let Some(mut wallpaper) = wallpaper {
|
|
wallpaper.alpha = progress;
|
|
elements.push(wallpaper.into());
|
|
}
|
|
if let Some(mut previous) = state.previous_theme_wallpaper(renderer, output) {
|
|
if !has_wallpaper {
|
|
previous.alpha = 1. - progress;
|
|
}
|
|
elements.push(previous.into());
|
|
}
|
|
backdrop::update(&elements, scale);
|
|
elements
|
|
}
|
|
|
|
pub(crate) fn layer_surfaces(output: &Output) -> Vec<LayerSurface> {
|
|
layer_map_for_output(output).layers().cloned().collect()
|
|
}
|
|
|
|
pub(super) fn layer_elements(
|
|
state: &mut Ferese,
|
|
renderer: &mut GlesRenderer,
|
|
output: &Output,
|
|
requested_layers: &[Layer],
|
|
) -> Vec<AnimatedWindowRenderElement> {
|
|
let scale = output.current_scale().fractional_scale();
|
|
let Some(mode) = output.current_mode() else {
|
|
return Vec::new();
|
|
};
|
|
let output_crop = Rectangle::<i32, Physical>::from_size(mode.size);
|
|
let layers = {
|
|
let map = layer_map_for_output(output);
|
|
|
|
requested_layers
|
|
.iter()
|
|
.flat_map(|requested| {
|
|
map.layers_on(*requested)
|
|
.rev()
|
|
.filter_map(|layer| map.layer_geometry(layer).map(|geometry| (geometry, layer.clone())))
|
|
})
|
|
.collect::<Vec<_>>()
|
|
};
|
|
|
|
state.render.surfaces.retain(|surface, _| {
|
|
surface.is_alive()
|
|
|| state
|
|
.render
|
|
.closing
|
|
.iter()
|
|
.any(|window| window.material.as_ref().is_some_and(|(key, ..)| key == surface))
|
|
});
|
|
|
|
let mut elements = Vec::new();
|
|
for (geometry, layer) in layers {
|
|
for (popup, offset) in PopupManager::popups_for_surface(layer.wl_surface()) {
|
|
let mut bounds = popup.geometry();
|
|
let content_origin = geometry.loc + offset - bounds.loc;
|
|
bounds.loc = geometry.loc + offset;
|
|
append_material_surface(
|
|
state,
|
|
renderer,
|
|
output,
|
|
popup.wl_surface(),
|
|
bounds,
|
|
content_origin,
|
|
scale,
|
|
output_crop,
|
|
&mut elements,
|
|
);
|
|
}
|
|
append_material_surface(
|
|
state,
|
|
renderer,
|
|
output,
|
|
layer.wl_surface(),
|
|
geometry,
|
|
geometry.loc,
|
|
scale,
|
|
output_crop,
|
|
&mut elements,
|
|
);
|
|
}
|
|
|
|
elements
|
|
}
|
|
|
|
pub(super) fn cursor_elements(
|
|
state: &Ferese,
|
|
renderer: &mut GlesRenderer,
|
|
output_geometry: Rectangle<i32, Logical>,
|
|
scale: f64,
|
|
) -> Vec<AnimatedWindowRenderElement> {
|
|
if state.input_capture.active() {
|
|
return Vec::new();
|
|
}
|
|
let Some(pointer) = state.seat.get_pointer() else {
|
|
return Vec::new();
|
|
};
|
|
let output_crop = Rectangle::<i32, Logical>::from_size(output_geometry.size).to_physical_precise_round(scale);
|
|
let origin = Point::<i32, Physical>::default();
|
|
let pointer_location = pointer.current_location() - output_geometry.loc.to_f64();
|
|
match &state.cursor_status {
|
|
CursorImageStatus::Surface(surface) => {
|
|
let hotspot = with_states(surface, |states| {
|
|
states
|
|
.data_map
|
|
.get::<CursorImageSurfaceData>()
|
|
.map(|attributes| attributes.lock().unwrap().hotspot)
|
|
.unwrap_or_default()
|
|
});
|
|
let physical_location = (pointer_location - hotspot.to_f64()).to_physical_precise_round(scale);
|
|
|
|
render_elements_from_surface_tree::<GlesRenderer, WaylandSurfaceRenderElement<GlesRenderer>>(
|
|
renderer,
|
|
surface,
|
|
physical_location,
|
|
scale,
|
|
1.0,
|
|
RenderElementKind::Cursor,
|
|
)
|
|
.into_iter()
|
|
.filter_map(|element| {
|
|
let element = RescaleRenderElement::from_element(element, origin, 1.0);
|
|
let element = RelocateRenderElement::from_element(element, origin, Relocate::Relative);
|
|
|
|
CropRenderElement::from_element(element, scale, output_crop).map(Into::into)
|
|
})
|
|
.collect()
|
|
}
|
|
CursorImageStatus::Named(_) => {
|
|
let Some(cursor) = state.named_cursor_frame() else {
|
|
return Vec::new();
|
|
};
|
|
let physical_location = cursor.physical_location(pointer_location, scale);
|
|
let Ok(element) = MemoryRenderBufferRenderElement::from_buffer(
|
|
renderer,
|
|
physical_location,
|
|
&cursor.buffer,
|
|
None,
|
|
None,
|
|
None,
|
|
RenderElementKind::Cursor,
|
|
) else {
|
|
return Vec::new();
|
|
};
|
|
|
|
let element = RescaleRenderElement::from_element(element, origin, 1.0);
|
|
let element = RelocateRenderElement::from_element(element, origin, Relocate::Relative);
|
|
|
|
CropRenderElement::from_element(element, scale, output_crop)
|
|
.map(|element| vec![element.into()])
|
|
.unwrap_or_default()
|
|
}
|
|
CursorImageStatus::Hidden => Vec::new(),
|
|
}
|
|
}
|