Samuel Onoja
7a7df0106c
Invalid configuration currently prevents login. Ferese now starts with built-in defaults and shows a notification when the shell is ready, leaving the file untouched. Loading and validation belong to the config module, while the theme module resolves appearance. Validation remains strict, and failed live reloads keep the active settings. The native Morph regression checks the animated input region and idle frame scheduling while its backing surface stays allocated. Validation: workspace and Python tests, formatting, Clippy, release build, and isolated Wayland startup/reload and panel-motion tests. Native CI includes the startup regression. Related: #28.
929 lines
37 KiB
Rust
929 lines
37 KiB
Rust
use super::*;
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub(super) fn append_material_surface(
|
|
state: &mut Ferese,
|
|
renderer: &mut GlesRenderer,
|
|
output: &Output,
|
|
surface: &smithay::reexports::wayland_server::protocol::wl_surface::WlSurface,
|
|
geometry: Rectangle<i32, Logical>,
|
|
content_origin: Point<i32, Logical>,
|
|
scale: f64,
|
|
output_crop: Rectangle<i32, Physical>,
|
|
elements: &mut Vec<AnimatedWindowRenderElement>,
|
|
) {
|
|
let radius =
|
|
if crate::effects::surface_role(surface).is_some_and(|(role, _)| role == crate::effects::SemanticRole::Panel) {
|
|
state.theme_settings.panel_radius
|
|
} else {
|
|
state.theme_settings.material_radius
|
|
};
|
|
let regions = crate::effects::surface_regions(surface);
|
|
let opacities = crate::effects::surface_region_opacities(surface);
|
|
let targets: Vec<_> = match ®ions {
|
|
None => vec![(geometry, RoundedRect::from_logical(geometry, scale, radius), 1.0)],
|
|
Some(regions) => regions
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(index, r)| {
|
|
material_region_geometry(*r, geometry, content_origin, scale).map(|(rect, corners)| {
|
|
(
|
|
rect,
|
|
corners,
|
|
opacities.get(index).copied().unwrap_or(1000) as f32 / 1000.0,
|
|
)
|
|
})
|
|
})
|
|
.collect(),
|
|
};
|
|
let materials: Vec<_> = targets
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(index, (rect, corners, alpha))| {
|
|
material_element(
|
|
state,
|
|
renderer,
|
|
output,
|
|
surface,
|
|
MaterialSurface {
|
|
shape_origin: content_origin,
|
|
geometry: *rect,
|
|
corners: *corners,
|
|
index,
|
|
capture_geometry: if crate::effects::surface_role(surface)
|
|
.is_some_and(|(role, _)| role == crate::effects::SemanticRole::Panel)
|
|
{
|
|
*rect
|
|
} else {
|
|
geometry
|
|
},
|
|
alpha: *alpha,
|
|
},
|
|
)
|
|
})
|
|
.collect();
|
|
if let Some(buffers) = state.render.surfaces.get_mut(surface) {
|
|
buffers.contexts.retain(|(_, _, index), _| *index < targets.len());
|
|
buffers.captures.retain(|(_, _, index), _| *index < targets.len());
|
|
}
|
|
let material = (!materials.is_empty() && regions.is_none()).then_some(());
|
|
let clip = material.as_ref().and_then(|_| {
|
|
let corners = targets.first()?.1;
|
|
let mode = output.current_mode()?;
|
|
let program = rounded_clip_program(&mut state.render, renderer)?;
|
|
Some((
|
|
program,
|
|
framebuffer_clip_rect(corners.rect, mode.size, output.current_transform().invert()),
|
|
corners.radius,
|
|
))
|
|
});
|
|
// Smithay element lists are front to back: content, material, shadow.
|
|
let content = render_elements_from_surface_tree::<GlesRenderer, WaylandSurfaceRenderElement<GlesRenderer>>(
|
|
renderer,
|
|
surface,
|
|
content_origin.to_physical_precise_round(scale),
|
|
scale,
|
|
crate::effects::surface_opacity(surface),
|
|
RenderElementKind::Unspecified,
|
|
);
|
|
elements.extend(content.into_iter().filter_map(|element| {
|
|
let origin = Point::<i32, Physical>::default();
|
|
let element = if let Some((program, clip_rect, radius)) = &clip {
|
|
WindowContentRenderElement::Rounded(RoundedSurfaceRenderElement {
|
|
inner: element,
|
|
programs: program.clone(),
|
|
clip_rect: *clip_rect,
|
|
radius: *radius,
|
|
clip_changed: false,
|
|
opaque_clip: None,
|
|
})
|
|
} else {
|
|
WindowContentRenderElement::Popup(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)
|
|
}));
|
|
for (background, shadow) in materials {
|
|
elements.push(background);
|
|
elements.push(shadow);
|
|
}
|
|
}
|
|
|
|
/// Preserve the surface-local fractional edges until the shared physical snap.
|
|
fn material_region_geometry(
|
|
region: [f64; 5],
|
|
geometry: Rectangle<i32, Logical>,
|
|
origin: Point<i32, Logical>,
|
|
scale: f64,
|
|
) -> Option<(Rectangle<i32, Logical>, RoundedRect)> {
|
|
let rect = Rectangle::<f64, Logical>::new(
|
|
(f64::from(origin.x) + region[0], f64::from(origin.y) + region[1]).into(),
|
|
(region[2], region[3]).into(),
|
|
)
|
|
.intersection(geometry.to_f64())?;
|
|
let corners = RoundedRect::new(
|
|
ferese_layout::Rect::new(rect.loc.x, rect.loc.y, rect.size.w, rect.size.h),
|
|
(0, 0).into(),
|
|
scale,
|
|
region[4],
|
|
);
|
|
Some((rect.to_i32_up(), corners))
|
|
}
|
|
|
|
/// Apply the same output transform as framebuffer_clip_rect to corner identity.
|
|
fn framebuffer_corner_radii(radii: [f32; 4], transform: Transform) -> [f32; 4] {
|
|
let size = Size::<f64, Physical>::from((1., 1.));
|
|
let mut transformed = [0.; 4];
|
|
for (radius, point) in radii.into_iter().zip([(0., 0.), (1., 0.), (1., 1.), (0., 1.)]) {
|
|
let point = transform.transform_point_in(Point::<f64, Physical>::from(point), &size);
|
|
let index = match (point.x > 0.5, point.y > 0.5) {
|
|
(false, false) => 0,
|
|
(true, false) => 1,
|
|
(true, true) => 2,
|
|
(false, true) => 3,
|
|
};
|
|
transformed[index] = radius;
|
|
}
|
|
transformed
|
|
}
|
|
|
|
pub(super) struct MaterialSurface {
|
|
pub shape_origin: Point<i32, Logical>,
|
|
pub geometry: Rectangle<i32, Logical>,
|
|
pub corners: RoundedRect,
|
|
pub index: usize,
|
|
pub capture_geometry: Rectangle<i32, Logical>,
|
|
pub alpha: f32,
|
|
}
|
|
|
|
pub(super) fn material_element(
|
|
state: &mut Ferese,
|
|
renderer: &mut GlesRenderer,
|
|
output: &Output,
|
|
surface: &smithay::reexports::wayland_server::protocol::wl_surface::WlSurface,
|
|
surface_geometry: MaterialSurface,
|
|
) -> Option<(AnimatedWindowRenderElement, AnimatedWindowRenderElement)> {
|
|
let (role, generation) = crate::effects::surface_role(surface)?;
|
|
material_element_with_role(
|
|
state,
|
|
renderer,
|
|
output,
|
|
surface,
|
|
surface_geometry,
|
|
(role, generation, crate::effects::surface_opacity(surface)),
|
|
)
|
|
}
|
|
|
|
fn resolve_surface_material(
|
|
role: crate::effects::SemanticRole,
|
|
settings: crate::config::ThemeSettings,
|
|
panel_opacity: Option<f32>,
|
|
panel_style: ferese_panel::PanelStyle,
|
|
) -> crate::effects::ResolvedMaterial {
|
|
let mut material = crate::effects::resolve_material(role, settings.material_style, settings.shell_opacity as f32);
|
|
if role == crate::effects::SemanticRole::Panel {
|
|
material.opacity = ferese_config::theme::effective_panel_opacity(
|
|
material.opacity,
|
|
panel_opacity,
|
|
settings.reduce_transparency,
|
|
);
|
|
if panel_style == ferese_panel::PanelStyle::Morph {
|
|
material.shadow = [0.; 3];
|
|
}
|
|
}
|
|
material
|
|
}
|
|
|
|
pub(super) fn material_element_with_role(
|
|
state: &mut Ferese,
|
|
renderer: &mut GlesRenderer,
|
|
output: &Output,
|
|
surface: &smithay::reexports::wayland_server::protocol::wl_surface::WlSurface,
|
|
surface_geometry: MaterialSurface,
|
|
(role, generation, opacity): (crate::effects::SemanticRole, u64, f32),
|
|
) -> Option<(AnimatedWindowRenderElement, AnimatedWindowRenderElement)> {
|
|
let MaterialSurface {
|
|
shape_origin,
|
|
geometry,
|
|
corners,
|
|
index,
|
|
capture_geometry,
|
|
alpha,
|
|
} = surface_geometry;
|
|
let material = resolve_surface_material(
|
|
role,
|
|
state.theme_settings,
|
|
state.panel_background_opacity,
|
|
state.panel_style,
|
|
);
|
|
let presentation_alpha = opacity * alpha;
|
|
let mode = output.current_mode()?;
|
|
let scale = output.current_scale().fractional_scale();
|
|
let transform = output.current_transform().invert();
|
|
let background = if role == crate::effects::SemanticRole::Panel {
|
|
state.theme_settings.bar_background_color
|
|
} else {
|
|
state.theme_settings.surface_base_color
|
|
};
|
|
let morph = role == crate::effects::SemanticRole::Panel && state.panel_style == ferese_panel::PanelStyle::Morph;
|
|
let background = if morph {
|
|
state.theme_settings.surface_raised_color
|
|
} else {
|
|
background
|
|
};
|
|
let [red, green, blue, _] = background.0;
|
|
let logical_radii = if role == crate::effects::SemanticRole::Panel {
|
|
state.panel_corner_radius
|
|
} else {
|
|
None
|
|
};
|
|
let radii = logical_radii.map_or([corners.radius; 4], |radii| {
|
|
radii
|
|
.0
|
|
.map(|value| clamp_radius(f64::from(value) * scale, corners.rect.size))
|
|
});
|
|
let output_size = output
|
|
.current_transform()
|
|
.transform_size(mode.size)
|
|
.to_f64()
|
|
.to_logical(scale)
|
|
.to_i32_ceil();
|
|
let touches_top = role == crate::effects::SemanticRole::Panel && geometry.loc.y == 0;
|
|
let touches_bottom =
|
|
role == crate::effects::SemanticRole::Panel && geometry.loc.y + geometry.size.h >= output_size.h;
|
|
let radii = ferese_panel::CornerRadii(radii)
|
|
.at_top_edge(touches_top)
|
|
.at_edge(ferese_panel::Edge::Bottom, touches_bottom)
|
|
.0;
|
|
let radius = radii.into_iter().fold(0., f32::max);
|
|
let corner_radii = framebuffer_corner_radii(radii, transform);
|
|
let [offset_y, shadow_blur, shadow_opacity] = material.shadow;
|
|
let edge_bar = radius == 0.0 && (touches_top || touches_bottom);
|
|
let shadow_opacity = if edge_bar {
|
|
0.0
|
|
} else {
|
|
shadow_opacity * (state.theme_settings.shadow_opacity / 0.2) * f64::from(presentation_alpha)
|
|
};
|
|
let shadow_opacity = if role == crate::effects::SemanticRole::Panel {
|
|
shadow_opacity * f64::from(material.opacity)
|
|
} else {
|
|
shadow_opacity
|
|
};
|
|
let shadow_geometry = Rectangle::new(
|
|
(
|
|
corners.rect.loc.x,
|
|
corners.rect.loc.y + (offset_y * scale).round() as i32,
|
|
)
|
|
.into(),
|
|
corners.rect.size,
|
|
);
|
|
let background_opacity = material.opacity;
|
|
let blur = material_blur_radius(material.style, material.opacity, state.theme_settings.backdrop_blur);
|
|
let sample_geometry = expanded_blur_region(capture_geometry, blur.ceil() as i32, output_size);
|
|
let sample_physical = sample_geometry.to_physical_precise_round(scale);
|
|
let panel = (role == crate::effects::SemanticRole::Panel)
|
|
.then(|| crate::effects::surface_panel_presentation(surface))
|
|
.flatten()
|
|
.map(|presentation| panel_matrices(&presentation, shape_origin, scale, mode.size, transform));
|
|
let opaque = panel.is_none() && material.opacity == 1.0 && presentation_alpha == 1.0 && radius == 0.0;
|
|
let mut parameters = MaterialParameters {
|
|
panel,
|
|
corner_radii,
|
|
presentation_alpha,
|
|
background_opacity,
|
|
blur: (blur * scale) as f32,
|
|
sample_geometry,
|
|
sample_physical,
|
|
sample_framebuffer: framebuffer_clip_rect(sample_physical, mode.size, transform),
|
|
shadow_rect: framebuffer_clip_rect(shadow_geometry, mode.size, transform),
|
|
shadow_values: [(shadow_blur * scale) as f32, shadow_opacity as f32],
|
|
shadow_bounds: shadow_bounds(geometry, offset_y, shadow_blur),
|
|
geometry,
|
|
tint: [red, green, blue, material.opacity * presentation_alpha],
|
|
generation,
|
|
opaque,
|
|
visible_framebuffer: framebuffer_clip_rect(corners.rect, mode.size, transform),
|
|
};
|
|
let context = renderer.context_id().erased();
|
|
let program = material_program(&mut state.render, renderer)?;
|
|
let blur_program = (blur > 0.0)
|
|
.then(|| blur_program(&mut state.render, renderer))
|
|
.flatten();
|
|
let capture_rect = framebuffer_capture_rect(parameters.sample_framebuffer);
|
|
let capture_size = Size::from((capture_rect[2], capture_rect[3]));
|
|
let output_id = state.output_id(output)?;
|
|
let capture_key = (context.clone(), output_id, index);
|
|
let buffers = state.render.surfaces.entry(surface.clone()).or_default();
|
|
let capture = if let Some(blur_program) = blur_program {
|
|
if buffers
|
|
.captures
|
|
.get(&capture_key)
|
|
.is_none_or(|c| c.geometry != sample_geometry || c.texture.size() != capture_size)
|
|
{
|
|
let texture = Offscreen::<GlesTexture>::create_buffer(renderer, Fourcc::Abgr8888, capture_size)
|
|
.map_err(|error| {
|
|
tracing::warn!(%error, ?sample_physical, "backdrop capture allocation failed");
|
|
error
|
|
})
|
|
.ok();
|
|
if let Some(texture) = texture {
|
|
buffers.captures.insert(
|
|
capture_key.clone(),
|
|
BlurCapture {
|
|
texture,
|
|
dirty: Arc::new(AtomicBool::new(true)),
|
|
geometry: sample_geometry,
|
|
},
|
|
);
|
|
} else {
|
|
buffers.captures.remove(&capture_key);
|
|
}
|
|
}
|
|
buffers
|
|
.captures
|
|
.get(&capture_key)
|
|
.cloned()
|
|
.map(|capture| (capture, blur_program))
|
|
} else {
|
|
buffers.captures.remove(&capture_key);
|
|
None
|
|
};
|
|
if capture.is_some() {
|
|
parameters.tint[3] = state.theme_settings.material_tint_strength as f32;
|
|
}
|
|
let make_element = || {
|
|
if let Some((capture, program)) = &capture {
|
|
MaterialElement::Blur(BlurRenderElement::new(
|
|
capture.texture.clone(),
|
|
program.0.clone(),
|
|
¶meters,
|
|
capture.dirty.clone(),
|
|
))
|
|
} else {
|
|
MaterialElement::Fill(SharedPixelShaderElement::new(
|
|
program.0.clone(),
|
|
geometry,
|
|
parameters.opaque.then(|| vec![Rectangle::from_size(geometry.size)]),
|
|
1.0,
|
|
material_uniforms(¶meters),
|
|
RenderElementKind::Unspecified,
|
|
))
|
|
}
|
|
};
|
|
let cached = buffers
|
|
.contexts
|
|
.entry((context, output_id, index))
|
|
.or_insert_with(|| CachedMaterial {
|
|
element: make_element(),
|
|
parameters: parameters.clone(),
|
|
shadow: SharedPixelShaderElement::new(
|
|
program.0.clone(),
|
|
parameters.shadow_bounds,
|
|
None,
|
|
1.0,
|
|
decoration_uniforms(¶meters, 2.0),
|
|
RenderElementKind::Unspecified,
|
|
),
|
|
});
|
|
let replace = match &cached.element {
|
|
MaterialElement::Fill(_) => capture.is_some(),
|
|
MaterialElement::Blur(element) => capture
|
|
.as_ref()
|
|
.is_none_or(|(capture, _)| capture.texture.tex_id() != element.texture.tex_id()),
|
|
};
|
|
if replace {
|
|
cached.element = make_element();
|
|
}
|
|
if cached.parameters != parameters {
|
|
if cached.parameters.shadow_rect != parameters.shadow_rect
|
|
|| cached.parameters.shadow_values != parameters.shadow_values
|
|
|| cached.parameters.shadow_bounds != parameters.shadow_bounds
|
|
|| cached.parameters.corner_radii != parameters.corner_radii
|
|
|| cached.parameters.visible_framebuffer != parameters.visible_framebuffer
|
|
|| cached.parameters.panel != parameters.panel
|
|
{
|
|
cached.shadow.resize(parameters.shadow_bounds, None);
|
|
cached.shadow.update_uniforms(decoration_uniforms(¶meters, 2.0));
|
|
}
|
|
match &mut cached.element {
|
|
MaterialElement::Fill(element) => {
|
|
element.resize(
|
|
geometry,
|
|
parameters.opaque.then(|| vec![Rectangle::from_size(geometry.size)]),
|
|
);
|
|
element.update_uniforms(material_uniforms(¶meters));
|
|
}
|
|
MaterialElement::Blur(element) => element.update(¶meters),
|
|
}
|
|
cached.parameters = parameters;
|
|
}
|
|
let background = match &cached.element {
|
|
// Keep the shader's opaque regions when its canvas already has the
|
|
// shared edges. Animated modal geometry may need a physical override.
|
|
MaterialElement::Fill(element) if element.geometry(scale.into()) == corners.rect => element.clone().into(),
|
|
MaterialElement::Fill(element) => PhysicalShaderElement {
|
|
inner: element.clone(),
|
|
geometry: corners.rect,
|
|
}
|
|
.into(),
|
|
MaterialElement::Blur(element) => element.clone().into(),
|
|
};
|
|
Some((background, cached.shadow.clone().into()))
|
|
}
|
|
|
|
pub(super) fn material_blur_radius(style: crate::config::MaterialStyle, opacity: f32, radius: f64) -> f64 {
|
|
if style == crate::config::MaterialStyle::Translucent && opacity > 0.0 {
|
|
radius
|
|
} else {
|
|
0.0
|
|
}
|
|
}
|
|
|
|
pub(super) fn blur_program(resources: &mut RenderResources, renderer: &mut GlesRenderer) -> Option<BlurProgram> {
|
|
let context = renderer.context_id().erased();
|
|
if let Some(program) = resources
|
|
.contexts
|
|
.get(&context)
|
|
.and_then(|programs| programs.blur.as_ref())
|
|
{
|
|
return Some(program.clone());
|
|
}
|
|
match renderer.compile_custom_texture_shader(corner_shader(BLUR_SHADER), &blur_uniform_names()) {
|
|
Ok(program) => {
|
|
let program = BlurProgram(program);
|
|
resources.contexts.entry(context).or_default().blur = Some(program.clone());
|
|
Some(program)
|
|
}
|
|
Err(error) => {
|
|
tracing::warn!(%error,"backdrop blur unavailable; using plain translucent fill");
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(super) fn blur_uniform_names() -> Vec<UniformName<'static>> {
|
|
let mut names = vec![
|
|
UniformName::new("visible_rect", UniformType::_4f),
|
|
UniformName::new("material_radii", UniformType::_4f),
|
|
UniformName::new("texture_size", UniformType::_2f),
|
|
UniformName::new("capture_origin", UniformType::_2f),
|
|
UniformName::new("blur_radius", UniformType::_1f),
|
|
UniformName::new("presentation_alpha", UniformType::_1f),
|
|
UniformName::new("background_opacity", UniformType::_1f),
|
|
UniformName::new("tint", UniformType::_4f),
|
|
];
|
|
names.extend(panel_uniform_names());
|
|
names
|
|
}
|
|
|
|
pub(super) fn blur_uniforms(p: &MaterialParameters) -> Vec<Uniform<'static>> {
|
|
let mut uniforms = vec![
|
|
Uniform::new("visible_rect", p.visible_framebuffer),
|
|
Uniform::new("material_radii", p.corner_radii),
|
|
Uniform::new("texture_size", [p.sample_framebuffer[2], p.sample_framebuffer[3]]),
|
|
Uniform::new("capture_origin", [p.sample_framebuffer[0], p.sample_framebuffer[1]]),
|
|
Uniform::new("blur_radius", p.blur),
|
|
Uniform::new("presentation_alpha", p.presentation_alpha),
|
|
Uniform::new("background_opacity", p.background_opacity),
|
|
Uniform::new("tint", p.tint),
|
|
];
|
|
uniforms.extend(panel_uniforms(p));
|
|
uniforms
|
|
}
|
|
|
|
pub(super) fn framebuffer_capture_rect(rect: [f32; 4]) -> [i32; 4] {
|
|
rect.map(|v| v.round() as i32)
|
|
}
|
|
|
|
pub(super) fn expanded_blur_region(
|
|
visible: Rectangle<i32, Logical>,
|
|
radius: i32,
|
|
output_size: Size<i32, Logical>,
|
|
) -> Rectangle<i32, Logical> {
|
|
let left = (visible.loc.x - radius).max(0);
|
|
let top = (visible.loc.y - radius).max(0);
|
|
let right = (visible.loc.x + visible.size.w + radius).min(output_size.w);
|
|
let bottom = (visible.loc.y + visible.size.h + radius).min(output_size.h);
|
|
Rectangle::new(
|
|
(left, top).into(),
|
|
((right - left).max(1), (bottom - top).max(1)).into(),
|
|
)
|
|
}
|
|
|
|
pub(super) fn material_program(
|
|
resources: &mut RenderResources,
|
|
renderer: &mut GlesRenderer,
|
|
) -> Option<MaterialProgram> {
|
|
material_program_for_corners(resources, renderer, CornerShape::Continuous)
|
|
}
|
|
|
|
pub(super) fn material_program_for_corners(
|
|
resources: &mut RenderResources,
|
|
renderer: &mut GlesRenderer,
|
|
shape: CornerShape,
|
|
) -> Option<MaterialProgram> {
|
|
let context = renderer.context_id().erased();
|
|
if let Some(program) = resources.contexts.get(&context).and_then(|programs| match shape {
|
|
CornerShape::Circular => programs.material.as_ref(),
|
|
CornerShape::Continuous => programs.window_material.as_ref(),
|
|
}) {
|
|
return Some(program.clone());
|
|
}
|
|
|
|
let mut uniforms = vec![
|
|
UniformName::new("visible_rect", UniformType::_4f),
|
|
UniformName::new("material_radii", UniformType::_4f),
|
|
UniformName::new("tint", UniformType::_4f),
|
|
UniformName::new("paint_mode", UniformType::_1f),
|
|
UniformName::new("shadow_rect", UniformType::_4f),
|
|
UniformName::new("shadow_values", UniformType::_2f),
|
|
];
|
|
uniforms.extend(panel_uniform_names());
|
|
match renderer.compile_custom_pixel_shader(corner_shader_for(MATERIAL_SHADER, shape), &uniforms) {
|
|
Ok(program) => {
|
|
let program = MaterialProgram(program);
|
|
let context = resources.contexts.entry(context).or_default();
|
|
match shape {
|
|
CornerShape::Circular => context.material = Some(program.clone()),
|
|
CornerShape::Continuous => context.window_material = Some(program.clone()),
|
|
}
|
|
Some(program)
|
|
}
|
|
Err(error) => {
|
|
tracing::error!(%error, "failed to compile semantic material shader");
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(super) fn material_uniforms(parameters: &MaterialParameters) -> Vec<Uniform<'static>> {
|
|
decoration_uniforms(parameters, 0.0)
|
|
}
|
|
|
|
pub(super) fn decoration_uniforms(parameters: &MaterialParameters, paint_mode: f32) -> Vec<Uniform<'static>> {
|
|
let mut uniforms = vec![
|
|
Uniform::new("paint_mode", paint_mode),
|
|
Uniform::new("shadow_rect", parameters.shadow_rect),
|
|
Uniform::new("shadow_values", parameters.shadow_values),
|
|
Uniform::new("visible_rect", parameters.visible_framebuffer),
|
|
Uniform::new("material_radii", parameters.corner_radii),
|
|
Uniform::new("tint", parameters.tint),
|
|
];
|
|
uniforms.extend(panel_uniforms(parameters));
|
|
uniforms
|
|
}
|
|
|
|
fn panel_uniform_names() -> [UniformName<'static>; 3] {
|
|
[
|
|
UniformName::new("panel_count", UniformType::_1f),
|
|
UniformName::new("panel_fusion", UniformType::_1f),
|
|
UniformName::new("panel_shapes[0]", UniformType::Matrix3x3),
|
|
]
|
|
}
|
|
|
|
fn panel_uniforms(parameters: &MaterialParameters) -> Vec<Uniform<'static>> {
|
|
use smithay::backend::renderer::gles::UniformValue;
|
|
let mut uniforms = vec![
|
|
Uniform::new(
|
|
"panel_count",
|
|
parameters.panel.as_ref().map_or(0., |p| p.shapes.len() as f32),
|
|
),
|
|
Uniform::new("panel_fusion", parameters.panel.as_ref().map_or(0., |p| p.fusion)),
|
|
];
|
|
if let Some(panel) = ¶meters.panel
|
|
&& !panel.shapes.is_empty()
|
|
{
|
|
uniforms.push(Uniform::new(
|
|
"panel_shapes[0]",
|
|
UniformValue::Matrix3x3 {
|
|
matrices: panel.shapes.clone(),
|
|
transpose: false,
|
|
},
|
|
));
|
|
}
|
|
uniforms
|
|
}
|
|
|
|
fn panel_matrices(
|
|
presentation: &crate::effects::PanelPresentation,
|
|
origin: Point<i32, Logical>,
|
|
scale: f64,
|
|
size: Size<i32, Physical>,
|
|
transform: Transform,
|
|
) -> PanelMatrices {
|
|
let permutation = framebuffer_corner_radii([0., 1., 2., 3.], transform);
|
|
// The shell snaps its path in surface-local pixels. Translate that path by
|
|
// the same physical origin as its Wayland content, rather than rounding
|
|
// origin + local coordinates together. At fractional scales the latter
|
|
// can separate shared edges after the f32 protocol round trip.
|
|
let origin: Point<i32, Physical> = origin.to_physical_precise_round(scale);
|
|
let shapes = presentation
|
|
.shapes
|
|
.iter()
|
|
.map(|primitive| {
|
|
let b = primitive.bounds;
|
|
let left = (b.x * scale).round() as i32 + origin.x;
|
|
let top = (b.y * scale).round() as i32 + origin.y;
|
|
let right = ((b.x + b.width) * scale).round() as i32 + origin.x;
|
|
let bottom = ((b.y + b.height) * scale).round() as i32 + origin.y;
|
|
let physical = Rectangle::new((left, top).into(), (right - left, bottom - top).into());
|
|
let rect = framebuffer_clip_rect(physical, size, transform);
|
|
let radii = primitive.radii.0.map(|r| (f64::from(r) * scale) as f32);
|
|
let radii = framebuffer_corner_radii(
|
|
ferese_panel::CornerRadii(radii)
|
|
.normalized(physical.size.w as f32, physical.size.h as f32)
|
|
.0,
|
|
transform,
|
|
);
|
|
let operation = if primitive.operation >= 2 {
|
|
let old_corner = match primitive.operation {
|
|
2 => 3,
|
|
3 => 2,
|
|
4 => 1,
|
|
_ => 0,
|
|
};
|
|
match permutation.iter().position(|i| *i == old_corner as f32).unwrap() {
|
|
0 => 5,
|
|
1 => 4,
|
|
2 => 3,
|
|
_ => 2,
|
|
}
|
|
} else {
|
|
primitive.operation
|
|
};
|
|
[
|
|
rect[0],
|
|
rect[1],
|
|
rect[2],
|
|
rect[3],
|
|
radii[0],
|
|
radii[1],
|
|
radii[2],
|
|
radii[3],
|
|
f32::from(operation * 4 + primitive.blend_zone),
|
|
]
|
|
})
|
|
.collect();
|
|
PanelMatrices {
|
|
shapes,
|
|
fusion: (presentation.fusion * scale) as f32,
|
|
}
|
|
}
|
|
|
|
pub(super) fn blur_damage(
|
|
size: Size<i32, Physical>,
|
|
current: CommitCounter,
|
|
previous: Option<CommitCounter>,
|
|
) -> DamageSet<i32, Physical> {
|
|
if previous == Some(current) {
|
|
DamageSet::default()
|
|
} else {
|
|
// A new scene needs its entire sampling halo repainted before capture.
|
|
DamageSet::from_slice(&[Rectangle::from_size((size.w, size.h).into())])
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod region_geometry_tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn reduce_transparency_wins_over_continuous_and_island_panel_materials() {
|
|
use crate::effects::SemanticRole;
|
|
for surface in ["flat", "floating", "morph"] {
|
|
for opacity in [0., 0.4, 1.] {
|
|
for reduce in [false, true] {
|
|
let source = format!(
|
|
"theme {{ material {{ style translucent; opacity 0.7; }}; accessibility {{ reduce-transparency #{reduce}; }}; }}; panel main {{ style {surface}; background-opacity {opacity}; }}"
|
|
);
|
|
let (_, runtime, candidate) =
|
|
crate::config::prepare(&source, std::path::Path::new("/tmp")).unwrap();
|
|
let material = resolve_surface_material(
|
|
SemanticRole::Panel,
|
|
runtime.theme_settings,
|
|
runtime.panel_background_opacity,
|
|
runtime.panel_style,
|
|
);
|
|
assert_eq!(material.opacity, if reduce { 1. } else { opacity });
|
|
assert_eq!(material.opacity, candidate.theme.panel_opacity(Some(opacity)));
|
|
assert_eq!(
|
|
material.style,
|
|
if reduce {
|
|
crate::config::MaterialStyle::Solid
|
|
} else {
|
|
crate::config::MaterialStyle::Translucent
|
|
}
|
|
);
|
|
if reduce {
|
|
assert_eq!(runtime.theme_settings.backdrop_blur, 0.);
|
|
}
|
|
let popover = resolve_surface_material(
|
|
SemanticRole::Popover,
|
|
runtime.theme_settings,
|
|
Some(0.),
|
|
runtime.panel_style,
|
|
);
|
|
assert!((popover.opacity - if reduce { 1. } else { 0.7 }).abs() < 0.001);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn morph_inherits_translucency_and_blur_without_adding_a_shadow() {
|
|
use crate::effects::SemanticRole;
|
|
for reduce in [false, true] {
|
|
let source = format!(
|
|
"theme {{ material {{ style translucent; opacity 0.6; blur-radius 20; }}; accessibility {{ reduce-transparency #{reduce}; }}; }}; panel main {{ style morph; }}"
|
|
);
|
|
let (_, runtime, candidate) = crate::config::prepare(&source, std::path::Path::new("/tmp")).unwrap();
|
|
let material =
|
|
resolve_surface_material(SemanticRole::Panel, runtime.theme_settings, None, runtime.panel_style);
|
|
assert_eq!(material.shadow, [0.; 3]);
|
|
assert_eq!(material.opacity, candidate.theme.panel_opacity(None));
|
|
assert_eq!(
|
|
material.style,
|
|
if reduce {
|
|
crate::config::MaterialStyle::Solid
|
|
} else {
|
|
crate::config::MaterialStyle::Translucent
|
|
}
|
|
);
|
|
let blur = material_blur_radius(material.style, material.opacity, runtime.theme_settings.backdrop_blur);
|
|
assert_eq!(blur > 0., !reduce);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn framebuffer_transforms_preserve_each_logical_corner() {
|
|
let radii = [1., 2., 3., 4.];
|
|
assert_eq!(framebuffer_corner_radii(radii, Transform::Normal), radii);
|
|
assert_eq!(framebuffer_corner_radii(radii, Transform::Flipped180), [4., 3., 2., 1.]);
|
|
for (transform, expected) in [
|
|
(Transform::Normal, [1., 2., 3., 4.]),
|
|
(Transform::_90, [4., 1., 2., 3.]),
|
|
(Transform::_180, [3., 4., 1., 2.]),
|
|
(Transform::_270, [2., 3., 4., 1.]),
|
|
(Transform::Flipped, [2., 1., 4., 3.]),
|
|
(Transform::Flipped90, [1., 4., 3., 2.]),
|
|
(Transform::Flipped180, [4., 3., 2., 1.]),
|
|
(Transform::Flipped270, [3., 2., 1., 4.]),
|
|
] {
|
|
assert_eq!(framebuffer_corner_radii(radii, transform), expected);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn attached_morph_masks_keep_shared_edges_after_wire_rounding() {
|
|
use ferese_panel::scene::{Parameters, Primitive, derive};
|
|
use ferese_panel::shape::PixelGrid;
|
|
for scale in [1., 1.25, 1.5, 2.] {
|
|
for origin in [-3, 0, 1, 3, 101] {
|
|
for width in [149.99, 150., 150.01, 199.99, 200., 200.01, 259.99, 260., 260.01] {
|
|
let scene = derive(
|
|
Parameters {
|
|
style: ferese_panel::PanelStyle::Morph,
|
|
attached: true,
|
|
fillet: 12.,
|
|
..Default::default()
|
|
},
|
|
ferese_layout::Rect::new((320. - width) / 2., 0., width, 44.),
|
|
&[],
|
|
PixelGrid::new(scale).unwrap(),
|
|
)
|
|
.unwrap();
|
|
let presentation = crate::effects::PanelPresentation {
|
|
shapes: scene
|
|
.packets()
|
|
.into_iter()
|
|
.map(|p| Primitive::from_packet(p).unwrap())
|
|
.collect::<Vec<_>>()
|
|
.into(),
|
|
fusion: 0.,
|
|
};
|
|
let shapes = panel_matrices(
|
|
&presentation,
|
|
(origin, 0).into(),
|
|
scale,
|
|
(1000, 1000).into(),
|
|
Transform::Normal,
|
|
)
|
|
.shapes;
|
|
let [body, left, right] = shapes.as_slice() else {
|
|
panic!("expected body and shoulders")
|
|
};
|
|
let client_left = (scene.paint[0].bounds.x * scale).round() + (f64::from(origin) * scale).round();
|
|
assert_eq!(
|
|
body[0], client_left as f32,
|
|
"native fill must align with the shell outline"
|
|
);
|
|
assert_eq!(
|
|
left[0] + left[2],
|
|
body[0],
|
|
"left join: scale {scale}, origin {origin}, width {width}"
|
|
);
|
|
assert_eq!(
|
|
body[0] + body[2],
|
|
right[0],
|
|
"right join: scale {scale}, origin {origin}, width {width}"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn attached_morph_material_covers_each_join_once_through_settlement() {
|
|
use ferese_panel::morph::{Hub, Mode, Profile};
|
|
use ferese_panel::scene::{Parameters, derive};
|
|
use ferese_panel::shape::{AnchoredRadii, PixelGrid};
|
|
for scale in [1., 1.25, 1.5, 2.] {
|
|
for edge in [ferese_panel::Edge::Top, ferese_panel::Edge::Bottom] {
|
|
let mut hub = Hub::new(Profile::default(), 34.).unwrap();
|
|
for mode in [Mode::Peek, Mode::Idle] {
|
|
hub.retarget(mode, [400., 300.]).unwrap();
|
|
for frame in 0..160 {
|
|
hub.advance(std::time::Duration::from_millis(8), false);
|
|
let sample = hub.sample();
|
|
let body = sample.geometry.bounds;
|
|
let bounds = ferese_layout::Rect::new(
|
|
(320. - body.width) / 2.,
|
|
if edge == ferese_panel::Edge::Top {
|
|
0.
|
|
} else {
|
|
64. - body.height
|
|
},
|
|
body.width,
|
|
body.height,
|
|
);
|
|
let scene = derive(
|
|
Parameters {
|
|
style: ferese_panel::PanelStyle::Morph,
|
|
attached: true,
|
|
edge,
|
|
fillet: 12.,
|
|
radius: Some(AnchoredRadii(sample.geometry.radii.map(|r| r as f32))),
|
|
..Default::default()
|
|
},
|
|
bounds,
|
|
&[],
|
|
PixelGrid::new(scale).unwrap(),
|
|
)
|
|
.unwrap();
|
|
// Reproduce the f32 transport and logical capture bounds used by native materials.
|
|
let regions: Vec<_> = scene
|
|
.damage
|
|
.iter()
|
|
.map(|r| {
|
|
material_region_geometry(
|
|
[r.x, r.y, r.width, r.height, 0.].map(|n| f64::from(n as f32)),
|
|
Rectangle::from_size((320, 64).into()),
|
|
(0, 0).into(),
|
|
scale,
|
|
)
|
|
.unwrap()
|
|
.0
|
|
.to_physical_precise_round(scale)
|
|
})
|
|
.collect();
|
|
let body = scene.paint[0].bounds;
|
|
let y = if edge == ferese_panel::Edge::Top {
|
|
2.
|
|
} else {
|
|
64. * scale - 3.
|
|
};
|
|
for join in [body.x, body.x + body.width] {
|
|
for side in [-1., 0.] {
|
|
let point = Point::<i32, Physical>::from((
|
|
(join * scale).round() as i32 + side as i32,
|
|
y as i32,
|
|
));
|
|
let coverage = regions.iter().filter(|r| r.contains(point)).count();
|
|
assert_eq!(
|
|
coverage, 1,
|
|
"join painted {coverage} times: {scale}, {edge:?}, {mode:?}, frame {frame}, {point:?}"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn fractional_regions_snap_once_in_output_pixels() {
|
|
let bounds = Rectangle::from_size((200, 100).into());
|
|
let (_, corners) = material_region_geometry([0.4, 0.4, 100.4, 40.4, 14.0], bounds, (0, 0).into(), 1.5).unwrap();
|
|
assert_eq!(corners.rect, Rectangle::new((1, 1).into(), (150, 60).into()));
|
|
assert_eq!(corners.radius, 21.0);
|
|
// The old logical rounding would put this at physical (0, 0).
|
|
let (_, clipped) =
|
|
material_region_geometry([-0.4, -0.4, 100.4, 40.4, 100.0], bounds, (0, 0).into(), 1.5).unwrap();
|
|
assert_eq!(clipped.rect, Rectangle::from_size((150, 60).into()));
|
|
assert_eq!(clipped.radius, 30.0);
|
|
assert!(material_region_geometry([300.0, 0.0, 10.0, 10.0, 2.0], bounds, (0, 0).into(), 1.5).is_none());
|
|
}
|
|
}
|