From 250aa1f3cbdea25575738e85d4598174db39effd Mon Sep 17 00:00:00 2001 From: Ivan Molodetskikh Date: Mon, 2 Feb 2026 16:32:42 +0300 Subject: [PATCH] Upgrade Smithay (framebuffer effect, subframes) --- Cargo.lock | 4 +-- Cargo.toml | 2 ++ niri-visual-tests/src/smithay_view.rs | 10 +++++- src/niri.rs | 36 ++++++++++++++++--- src/render_helpers/border.rs | 6 +++- src/render_helpers/clipped_surface.rs | 15 ++++++-- src/render_helpers/damage.rs | 2 ++ src/render_helpers/gradient_fade_texture.rs | 23 ++++++++++-- src/render_helpers/mod.rs | 10 +++++- src/render_helpers/offscreen.rs | 13 ++++++- src/render_helpers/primary_gpu_texture.rs | 23 ++++++++++-- src/render_helpers/render_elements.rs | 40 +++++++++++++++++++-- src/render_helpers/resize.rs | 15 ++++++-- src/render_helpers/shader_element.rs | 5 ++- src/render_helpers/shadow.rs | 6 +++- src/render_helpers/solid_color.rs | 2 ++ src/render_helpers/texture.rs | 2 ++ src/render_helpers/xray.rs | 13 ++++++- 18 files changed, 203 insertions(+), 24 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index cc3e32a0..206ea36c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3475,7 +3475,7 @@ checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c" [[package]] name = "smithay" version = "0.7.0" -source = "git+https://github.com/Smithay/smithay.git#f1d0d2c43e843233119af3dcf76d619e1afff4ee" +source = "git+https://github.com/Smithay/smithay.git?rev=dce4d34e7421559b661af9c519904f4b24346148#dce4d34e7421559b661af9c519904f4b24346148" dependencies = [ "aliasable", "appendlist", @@ -3550,7 +3550,7 @@ dependencies = [ [[package]] name = "smithay-drm-extras" version = "0.1.0" -source = "git+https://github.com/Smithay/smithay.git#f1d0d2c43e843233119af3dcf76d619e1afff4ee" +source = "git+https://github.com/Smithay/smithay.git?rev=dce4d34e7421559b661af9c519904f4b24346148#dce4d34e7421559b661af9c519904f4b24346148" dependencies = [ "drm", "libdisplay-info", diff --git a/Cargo.toml b/Cargo.toml index 8e62e8c7..91ff2638 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -31,12 +31,14 @@ tracy-client = { version = "0.18.4", default-features = false } [workspace.dependencies.smithay] # version = "0.4.1" git = "https://github.com/Smithay/smithay.git" +rev = "dce4d34e7421559b661af9c519904f4b24346148" # path = "../smithay" default-features = false [workspace.dependencies.smithay-drm-extras] # version = "0.1.0" git = "https://github.com/Smithay/smithay.git" +rev = "dce4d34e7421559b661af9c519904f4b24346148" # path = "../smithay/smithay-drm-extras" [package] diff --git a/niri-visual-tests/src/smithay_view.rs b/niri-visual-tests/src/smithay_view.rs index 5a8168c9..f5a9d106 100644 --- a/niri-visual-tests/src/smithay_view.rs +++ b/niri-visual-tests/src/smithay_view.rs @@ -20,6 +20,7 @@ mod imp { use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture}; use smithay::backend::renderer::{Bind, Color32F, Frame, Offscreen, Renderer}; use smithay::reexports::gbm::Format as Fourcc; + use smithay::utils::user_data::UserDataMap; use smithay::utils::{Physical, Rectangle, Scale, Transform}; use super::*; @@ -206,8 +207,15 @@ mod imp { if let Some(mut damage) = rect.intersection(dst) { damage.loc -= dst.loc; + + let cache = UserDataMap::new(); + if element.is_framebuffer_effect() { + element + .capture_framebuffer(&mut frame, src, dst, &cache) + .context("error in capture_framebuffer()")?; + } element - .draw(&mut frame, src, dst, &[damage], &[]) + .draw(&mut frame, src, dst, &[damage], &[], Some(&cache)) .context("error drawing element")?; } } diff --git a/src/niri.rs b/src/niri.rs index da3e7a5a..08e986a1 100644 --- a/src/niri.rs +++ b/src/niri.rs @@ -4688,6 +4688,7 @@ impl Niri { surface, output, states, + None, render_element_states, default_primary_scanout_output_compare, ); @@ -4706,6 +4707,7 @@ impl Niri { surface, output, states, + None, render_element_states, default_primary_scanout_output_compare, ); @@ -4762,6 +4764,7 @@ impl Niri { primary_scanout_output.update_from_render_element_states( id, output, + None, render_element_states, |_, _, output, _| output, ); @@ -4807,6 +4810,7 @@ impl Niri { primary_scanout_output.update_from_render_element_states( id, output, + None, render_element_states, // Layer surfaces are shown only on one output at a time. |_, _, output, _| output, @@ -4821,6 +4825,7 @@ impl Niri { surface, output, states, + None, render_element_states, // Layer surfaces are shown only on one output at a time. |_, _, output, _| output, @@ -4839,6 +4844,7 @@ impl Niri { surface, output, states, + None, render_element_states, default_primary_scanout_output_compare, ); @@ -5110,7 +5116,11 @@ impl Niri { &mut feedback, surface_primary_scanout_output, |surface, _| { - surface_presentation_feedback_flags_from_states(surface, render_element_states) + surface_presentation_feedback_flags_from_states( + surface, + None, + render_element_states, + ) }, ); } @@ -5121,7 +5131,11 @@ impl Niri { &mut feedback, surface_primary_scanout_output, |surface, _| { - surface_presentation_feedback_flags_from_states(surface, render_element_states) + surface_presentation_feedback_flags_from_states( + surface, + None, + render_element_states, + ) }, ); } @@ -5131,7 +5145,11 @@ impl Niri { &mut feedback, surface_primary_scanout_output, |surface, _| { - surface_presentation_feedback_flags_from_states(surface, render_element_states) + surface_presentation_feedback_flags_from_states( + surface, + None, + render_element_states, + ) }, ) } @@ -5141,7 +5159,11 @@ impl Niri { &mut feedback, surface_primary_scanout_output, |surface, _| { - surface_presentation_feedback_flags_from_states(surface, render_element_states) + surface_presentation_feedback_flags_from_states( + surface, + None, + render_element_states, + ) }, ); } @@ -5152,7 +5174,11 @@ impl Niri { &mut feedback, surface_primary_scanout_output, |surface, _| { - surface_presentation_feedback_flags_from_states(surface, render_element_states) + surface_presentation_feedback_flags_from_states( + surface, + None, + render_element_states, + ) }, ); } diff --git a/src/render_helpers/border.rs b/src/render_helpers/border.rs index aab8a85a..923066ef 100644 --- a/src/render_helpers/border.rs +++ b/src/render_helpers/border.rs @@ -9,6 +9,7 @@ use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, Unde use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, Uniform}; use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions}; use smithay::gpu_span_location; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform}; use super::renderer::NiriRenderer; @@ -285,6 +286,7 @@ impl RenderElement for BorderRenderElement { dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), GlesError> { let _span = tracy_client::span!("BorderRenderElement::draw"); frame.with_gpu_span(gpu_span_location!("BorderRenderElement::draw"), |frame| { @@ -295,6 +297,7 @@ impl RenderElement for BorderRenderElement { dst, damage, opaque_regions, + cache, ) }) } @@ -312,9 +315,10 @@ impl<'render> RenderElement> for BorderRenderElement { dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), TtyRendererError<'render>> { let frame = frame.as_gles_frame(); - RenderElement::::draw(self, frame, src, dst, damage, opaque_regions)?; + RenderElement::::draw(self, frame, src, dst, damage, opaque_regions, cache)?; Ok(()) } diff --git a/src/render_helpers/clipped_surface.rs b/src/render_helpers/clipped_surface.rs index 7eeb0aae..5a238015 100644 --- a/src/render_helpers/clipped_surface.rs +++ b/src/render_helpers/clipped_surface.rs @@ -6,6 +6,7 @@ use smithay::backend::renderer::gles::{ GlesError, GlesFrame, GlesRenderer, GlesTexProgram, Uniform, }; use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions}; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform}; use super::damage::ExtraDamage; @@ -228,9 +229,18 @@ impl RenderElement for ClippedSurfaceRenderElement { dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), GlesError> { frame.override_default_tex_program(self.program.clone(), self.compute_uniforms()); - RenderElement::::draw(&self.inner, frame, src, dst, damage, opaque_regions)?; + RenderElement::::draw( + &self.inner, + frame, + src, + dst, + damage, + opaque_regions, + cache, + )?; frame.clear_tex_program_override(); Ok(()) } @@ -252,11 +262,12 @@ impl<'render> RenderElement> dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), TtyRendererError<'render>> { frame .as_gles_frame() .override_default_tex_program(self.program.clone(), self.compute_uniforms()); - RenderElement::draw(&self.inner, frame, src, dst, damage, opaque_regions)?; + RenderElement::draw(&self.inner, frame, src, dst, damage, opaque_regions, cache)?; frame.as_gles_frame().clear_tex_program_override(); Ok(()) } diff --git a/src/render_helpers/damage.rs b/src/render_helpers/damage.rs index 4cc39820..b1e113bb 100644 --- a/src/render_helpers/damage.rs +++ b/src/render_helpers/damage.rs @@ -1,6 +1,7 @@ use smithay::backend::renderer::element::{Element, Id, RenderElement}; use smithay::backend::renderer::utils::CommitCounter; use smithay::backend::renderer::Renderer; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Buffer, Logical, Physical, Rectangle, Scale, Size}; #[derive(Debug, Clone)] @@ -62,6 +63,7 @@ impl RenderElement for ExtraDamage { _dst: Rectangle, _damage: &[Rectangle], _opaque_regions: &[Rectangle], + _cache: Option<&UserDataMap>, ) -> Result<(), R::Error> { Ok(()) } diff --git a/src/render_helpers/gradient_fade_texture.rs b/src/render_helpers/gradient_fade_texture.rs index a3a6b59a..bbdfef40 100644 --- a/src/render_helpers/gradient_fade_texture.rs +++ b/src/render_helpers/gradient_fade_texture.rs @@ -3,6 +3,7 @@ use smithay::backend::renderer::gles::{ GlesError, GlesFrame, GlesRenderer, GlesTexProgram, GlesTexture, Uniform, }; use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions}; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Buffer, Physical, Rectangle, Scale, Transform}; use super::texture::TextureRenderElement; @@ -96,10 +97,19 @@ impl RenderElement for GradientFadeTextureRenderElement { dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), GlesError> { let uniforms = vec![Uniform::new("cutoff", self.cutoff)]; frame.override_default_tex_program(self.program.0.clone(), uniforms); - RenderElement::::draw(&self.inner, frame, src, dst, damage, opaque_regions)?; + RenderElement::::draw( + &self.inner, + frame, + src, + dst, + damage, + opaque_regions, + cache, + )?; frame.clear_tex_program_override(); Ok(()) } @@ -119,9 +129,18 @@ impl<'render> RenderElement> for GradientFadeTextureRenderE dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), TtyRendererError<'render>> { let gles_frame = frame.as_gles_frame(); - RenderElement::::draw(&self, gles_frame, src, dst, damage, opaque_regions)?; + RenderElement::::draw( + &self, + gles_frame, + src, + dst, + damage, + opaque_regions, + cache, + )?; Ok(()) } diff --git a/src/render_helpers/mod.rs b/src/render_helpers/mod.rs index 64ea997f..321fdb0c 100644 --- a/src/render_helpers/mod.rs +++ b/src/render_helpers/mod.rs @@ -15,6 +15,7 @@ use smithay::backend::renderer::{ }; use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer; use smithay::reexports::wayland_server::protocol::wl_shm; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Logical, Physical, Point, Rectangle, Scale, Size, Transform}; use smithay::wayland::shm; use solid_color::{SolidColorBuffer, SolidColorRenderElement}; @@ -359,8 +360,15 @@ fn render_elements( if let Some(mut damage) = output_rect.intersection(dst) { damage.loc -= dst.loc; + + let cache = UserDataMap::new(); + if element.is_framebuffer_effect() { + element + .capture_framebuffer(&mut frame, src, dst, &cache) + .context("error in capture_framebuffer()")?; + } element - .draw(&mut frame, src, dst, &[damage], &[]) + .draw(&mut frame, src, dst, &[damage], &[], Some(&cache)) .context("error drawing element")?; } } diff --git a/src/render_helpers/offscreen.rs b/src/render_helpers/offscreen.rs index 655784f3..2f624b17 100644 --- a/src/render_helpers/offscreen.rs +++ b/src/render_helpers/offscreen.rs @@ -15,6 +15,7 @@ use smithay::backend::renderer::utils::{ use smithay::backend::renderer::{ Bind as _, Color32F, ContextId, Frame as _, Offscreen as _, Renderer, Texture as _, }; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform}; use super::encompassing_geo; @@ -306,6 +307,7 @@ impl RenderElement for OffscreenRenderElement { dest: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + _cache: Option<&UserDataMap>, ) -> Result<(), GlesError> { if frame.context_id() != self.renderer_context_id { warn!("trying to render texture from different renderer"); @@ -340,9 +342,18 @@ impl<'render> RenderElement> for OffscreenRenderElement { dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), TtyRendererError<'render>> { let gles_frame = frame.as_gles_frame(); - RenderElement::::draw(&self, gles_frame, src, dst, damage, opaque_regions)?; + RenderElement::::draw( + &self, + gles_frame, + src, + dst, + damage, + opaque_regions, + cache, + )?; Ok(()) } diff --git a/src/render_helpers/primary_gpu_texture.rs b/src/render_helpers/primary_gpu_texture.rs index 85dbc5b1..4cdec64c 100644 --- a/src/render_helpers/primary_gpu_texture.rs +++ b/src/render_helpers/primary_gpu_texture.rs @@ -1,6 +1,7 @@ use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage}; use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, GlesTexture}; use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions}; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Buffer, Physical, Rectangle, Scale, Transform}; use super::renderer::AsGlesFrame; @@ -61,9 +62,18 @@ impl RenderElement for PrimaryGpuTextureRenderElement { dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), GlesError> { let gles_frame = frame.as_gles_frame(); - RenderElement::::draw(&self.0, gles_frame, src, dst, damage, opaque_regions)?; + RenderElement::::draw( + &self.0, + gles_frame, + src, + dst, + damage, + opaque_regions, + cache, + )?; Ok(()) } @@ -82,9 +92,18 @@ impl<'render> RenderElement> for PrimaryGpuTextureRenderEle dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), TtyRendererError<'render>> { let gles_frame = frame.as_gles_frame(); - RenderElement::::draw(&self.0, gles_frame, src, dst, damage, opaque_regions)?; + RenderElement::::draw( + &self.0, + gles_frame, + src, + dst, + damage, + opaque_regions, + cache, + )?; Ok(()) } diff --git a/src/render_helpers/render_elements.rs b/src/render_helpers/render_elements.rs index e030c29b..f423b240 100644 --- a/src/render_helpers/render_elements.rs +++ b/src/render_helpers/render_elements.rs @@ -93,11 +93,31 @@ macro_rules! niri_render_elements { $($name::$variant(elem) => elem.kind()),+ } } + + fn is_framebuffer_effect(&self) -> bool { + match self { + $($name::$variant(elem) => elem.is_framebuffer_effect()),+ + } + } } impl smithay::backend::renderer::element::RenderElement for $($name_R)? $($name_no_R)? { + fn capture_framebuffer( + &self, + frame: &mut smithay::backend::renderer::gles::GlesFrame<'_, '_>, + src: smithay::utils::Rectangle, + dst: smithay::utils::Rectangle, + cache: &smithay::utils::user_data::UserDataMap, + ) -> Result<(), smithay::backend::renderer::gles::GlesError> { + match self { + $($name::$variant(elem) => { + smithay::backend::renderer::element::RenderElement::::capture_framebuffer(elem, frame, src, dst, cache) + })+ + } + } + fn draw( &self, frame: &mut smithay::backend::renderer::gles::GlesFrame<'_, '_>, @@ -105,10 +125,11 @@ macro_rules! niri_render_elements { dst: smithay::utils::Rectangle, damage: &[smithay::utils::Rectangle], opaque_regions: &[smithay::utils::Rectangle], + cache: Option<&smithay::utils::user_data::UserDataMap>, ) -> Result<(), smithay::backend::renderer::gles::GlesError> { match self { $($name::$variant(elem) => { - smithay::backend::renderer::element::RenderElement::::draw(elem, frame, src, dst, damage, opaque_regions) + smithay::backend::renderer::element::RenderElement::::draw(elem, frame, src, dst, damage, opaque_regions, cache) })+ } } @@ -123,6 +144,20 @@ macro_rules! niri_render_elements { impl<'render> smithay::backend::renderer::element::RenderElement<$crate::backend::tty::TtyRenderer<'render>> for $($name_R<$crate::backend::tty::TtyRenderer<'render>>)? $($name_no_R)? { + fn capture_framebuffer( + &self, + frame: &mut $crate::backend::tty::TtyFrame<'render, '_, '_>, + src: smithay::utils::Rectangle, + dst: smithay::utils::Rectangle, + cache: &smithay::utils::user_data::UserDataMap, + ) -> Result<(), $crate::backend::tty::TtyRendererError<'render>> { + match self { + $($name::$variant(elem) => { + smithay::backend::renderer::element::RenderElement::<$crate::backend::tty::TtyRenderer<'render>>::capture_framebuffer(elem, frame, src, dst, cache) + })+ + } + } + fn draw( &self, frame: &mut $crate::backend::tty::TtyFrame<'render, '_, '_>, @@ -130,10 +165,11 @@ macro_rules! niri_render_elements { dst: smithay::utils::Rectangle, damage: &[smithay::utils::Rectangle], opaque_regions: &[smithay::utils::Rectangle], + cache: Option<&smithay::utils::user_data::UserDataMap>, ) -> Result<(), $crate::backend::tty::TtyRendererError<'render>> { match self { $($name::$variant(elem) => { - smithay::backend::renderer::element::RenderElement::<$crate::backend::tty::TtyRenderer<'render>>::draw(elem, frame, src, dst, damage, opaque_regions) + smithay::backend::renderer::element::RenderElement::<$crate::backend::tty::TtyRenderer<'render>>::draw(elem, frame, src, dst, damage, opaque_regions, cache) })+ } } diff --git a/src/render_helpers/resize.rs b/src/render_helpers/resize.rs index a413e7a2..79b26dbf 100644 --- a/src/render_helpers/resize.rs +++ b/src/render_helpers/resize.rs @@ -8,6 +8,7 @@ use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, GlesT use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions}; use smithay::backend::renderer::Texture as _; use smithay::gpu_span_location; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Buffer, Logical, Physical, Rectangle, Scale, Size, Transform}; use super::renderer::{AsGlesFrame, NiriRenderer}; @@ -171,10 +172,19 @@ impl RenderElement for ResizeRenderElement { dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), GlesError> { let _span = tracy_client::span!("ResizeRenderElement::draw"); frame.with_gpu_span(gpu_span_location!("ResizeRenderElement::draw"), |frame| { - RenderElement::::draw(&self.0, frame, src, dst, damage, opaque_regions) + RenderElement::::draw( + &self.0, + frame, + src, + dst, + damage, + opaque_regions, + cache, + ) }) } @@ -191,9 +201,10 @@ impl<'render> RenderElement> for ResizeRenderElement { dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), TtyRendererError<'render>> { let frame = frame.as_gles_frame(); - RenderElement::::draw(self, frame, src, dst, damage, opaque_regions)?; + RenderElement::::draw(self, frame, src, dst, damage, opaque_regions, cache)?; Ok(()) } diff --git a/src/render_helpers/shader_element.rs b/src/render_helpers/shader_element.rs index 19c5b5a9..f1bf978b 100644 --- a/src/render_helpers/shader_element.rs +++ b/src/render_helpers/shader_element.rs @@ -10,6 +10,7 @@ use smithay::backend::renderer::gles::{ }; use smithay::backend::renderer::utils::{CommitCounter, OpaqueRegions}; use smithay::backend::renderer::DebugFlags; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size}; use super::renderer::AsGlesFrame; @@ -293,6 +294,7 @@ impl RenderElement for ShaderRenderElement { dest: Rectangle, damage: &[Rectangle], _opaque_regions: &[Rectangle], + _cache: Option<&UserDataMap>, ) -> Result<(), GlesError> { let _span = tracy_client::span!("ShaderRenderElement::draw"); @@ -527,10 +529,11 @@ impl<'render> RenderElement> for ShaderRenderElement { dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), TtyRendererError<'render>> { let frame = frame.as_gles_frame(); - RenderElement::::draw(self, frame, src, dst, damage, opaque_regions)?; + RenderElement::::draw(self, frame, src, dst, damage, opaque_regions, cache)?; Ok(()) } diff --git a/src/render_helpers/shadow.rs b/src/render_helpers/shadow.rs index 6c8db334..0d26201c 100644 --- a/src/render_helpers/shadow.rs +++ b/src/render_helpers/shadow.rs @@ -7,6 +7,7 @@ use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, Unde use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, Uniform}; use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions}; use smithay::gpu_span_location; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform}; use super::renderer::NiriRenderer; @@ -246,6 +247,7 @@ impl RenderElement for ShadowRenderElement { dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), GlesError> { let _span = tracy_client::span!("ShadowRenderElement::draw"); frame.with_gpu_span(gpu_span_location!("ShadowRenderElement::draw"), |frame| { @@ -256,6 +258,7 @@ impl RenderElement for ShadowRenderElement { dst, damage, opaque_regions, + cache, ) }) } @@ -273,9 +276,10 @@ impl<'render> RenderElement> for ShadowRenderElement { dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), TtyRendererError<'render>> { let frame = frame.as_gles_frame(); - RenderElement::::draw(self, frame, src, dst, damage, opaque_regions)?; + RenderElement::::draw(self, frame, src, dst, damage, opaque_regions, cache)?; Ok(()) } diff --git a/src/render_helpers/solid_color.rs b/src/render_helpers/solid_color.rs index 8cf9cca8..0c179f0d 100644 --- a/src/render_helpers/solid_color.rs +++ b/src/render_helpers/solid_color.rs @@ -1,6 +1,7 @@ use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage}; use smithay::backend::renderer::utils::{CommitCounter, OpaqueRegions}; use smithay::backend::renderer::{Color32F, Frame as _, Renderer}; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size}; /// Smithay's solid color buffer, but with fractional scale. @@ -158,6 +159,7 @@ impl RenderElement for SolidColorRenderElement { dst: Rectangle, damage: &[Rectangle], _opaque_regions: &[Rectangle], + _cache: Option<&UserDataMap>, ) -> Result<(), R::Error> { frame.draw_solid(dst, damage, self.color) } diff --git a/src/render_helpers/texture.rs b/src/render_helpers/texture.rs index 1d653c45..5e52950a 100644 --- a/src/render_helpers/texture.rs +++ b/src/render_helpers/texture.rs @@ -3,6 +3,7 @@ use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, Unde use smithay::backend::renderer::gles::GlesTexture; use smithay::backend::renderer::utils::{CommitCounter, OpaqueRegions}; use smithay::backend::renderer::{ContextId, Frame as _, ImportMem, Renderer, Texture}; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform}; use super::memory::MemoryBuffer; @@ -230,6 +231,7 @@ where dest: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + _cache: Option<&UserDataMap>, ) -> Result<(), R::Error> { if frame.context_id() != self.buffer.renderer_context_id { warn!("trying to render texture from different renderer"); diff --git a/src/render_helpers/xray.rs b/src/render_helpers/xray.rs index 12c640bf..f4b4f861 100644 --- a/src/render_helpers/xray.rs +++ b/src/render_helpers/xray.rs @@ -10,6 +10,7 @@ use smithay::backend::renderer::gles::{ }; use smithay::backend::renderer::utils::{CommitCounter, OpaqueRegions}; use smithay::backend::renderer::Color32F; +use smithay::utils::user_data::UserDataMap; use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform}; use crate::backend::tty::{TtyFrame, TtyRenderer, TtyRendererError}; @@ -303,6 +304,7 @@ impl RenderElement for XrayElement { dst: Rectangle, damage: &[Rectangle], _opaque_regions: &[Rectangle], + _cache: Option<&UserDataMap>, ) -> Result<(), GlesError> { let mut buffer = self.buffer.borrow_mut(); let texture = match buffer.render(frame, self.blur) { @@ -363,9 +365,18 @@ impl<'render> RenderElement> for XrayElement { dst: Rectangle, damage: &[Rectangle], opaque_regions: &[Rectangle], + cache: Option<&UserDataMap>, ) -> Result<(), TtyRendererError<'render>> { let gles_frame = frame.as_gles_frame(); - RenderElement::::draw(&self, gles_frame, src, dst, damage, opaque_regions)?; + RenderElement::::draw( + &self, + gles_frame, + src, + dst, + damage, + opaque_regions, + cache, + )?; Ok(()) } }