leyoda/cosmic-comp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: smithay update

Browse source
This commit is contained in:
Victoria Brekenfeld 2025-03-11 19:14:49 +01:00 • committed by Victoria Brekenfeld
parent f8fae8a5b0
commit 95b27637ae
23 changed files with 336 additions and 373 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/backend/render/cursor.rs
View file

@ -131,7 +131,7 @@ pub fn draw_surface_cursor<R>(
) -> Vec<(CursorRenderElement<R>, Point<i32, BufferCoords>)>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static,
R::TextureId: Clone + 'static,
{
let position = location.into();
let scale = scale.into();
@ -172,7 +172,7 @@ pub fn draw_dnd_icon<R>(
) -> Vec<WaylandSurfaceRenderElement<R>>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static,
R::TextureId: Clone + 'static,
{
if get_role(&surface) != Some("dnd_icon") {
warn!(
@ -262,7 +262,7 @@ pub fn draw_cursor<R>(
) -> Vec<(CursorRenderElement<R>, Point<i32, BufferCoords>)>
where
R: Renderer + ImportMem + ImportAll,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
{
// draw the cursor as relevant
// reset the cursor if the surface is no longer alive

46
src/backend/render/element.rs
View file

@ -22,7 +22,7 @@ use super::{cursor::CursorRenderElement, GlMultiRenderer};
pub enum CosmicElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
Workspace(
@ -45,7 +45,7 @@ where
impl<R> Element for CosmicElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn id(&self) -> &Id {
@ -196,13 +196,13 @@ where
impl<R> RenderElement<R> for CosmicElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Error: FromGlesError,
R::TextureId: 'static,
R::Error: FromGlesError,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn draw(
&self,
frame: &mut R::Frame<'_>,
frame: &mut R::Frame<'_, '_>,
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
@ -286,7 +286,7 @@ impl<R> From<CropRenderElement<RescaleRenderElement<WorkspaceRenderElement<R>>>>
for CosmicElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: CropRenderElement<RescaleRenderElement<WorkspaceRenderElement<R>>>) -> Self {
@ -301,7 +301,7 @@ where
impl<R> From<DamageElement> for CosmicElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: DamageElement) -> Self {
@ -312,7 +312,7 @@ where
impl<R> From<MemoryRenderBufferRenderElement<R>> for CosmicElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(value: MemoryRenderBufferRenderElement<R>) -> Self {
@ -324,7 +324,7 @@ where
impl<R> From<TextureRenderElement<GlesTexture>> for CosmicElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: TextureRenderElement<GlesTexture>) -> Self {
@ -338,8 +338,12 @@ where
{
fn glow_renderer(&self) -> &GlowRenderer;
fn glow_renderer_mut(&mut self) -> &mut GlowRenderer;
fn glow_frame<'a, 'frame>(frame: &'a Self::Frame<'frame>) -> &'a GlowFrame<'frame>;
fn glow_frame_mut<'a, 'frame>(frame: &'a mut Self::Frame<'frame>) -> &'a mut GlowFrame<'frame>;
fn glow_frame<'a, 'frame, 'buffer>(
frame: &'a Self::Frame<'frame, 'buffer>,
) -> &'a GlowFrame<'frame, 'buffer>;
fn glow_frame_mut<'a, 'frame, 'buffer>(
frame: &'a mut Self::Frame<'frame, 'buffer>,
) -> &'a mut GlowFrame<'frame, 'buffer>;
}
impl AsGlowRenderer for GlowRenderer {
@ -349,10 +353,14 @@ impl AsGlowRenderer for GlowRenderer {
fn glow_renderer_mut(&mut self) -> &mut GlowRenderer {
self
}
fn glow_frame<'a, 'frame>(frame: &'a Self::Frame<'frame>) -> &'a GlowFrame<'frame> {
fn glow_frame<'a, 'frame, 'buffer>(
frame: &'a Self::Frame<'frame, 'buffer>,
) -> &'a GlowFrame<'frame, 'buffer> {
frame
}
fn glow_frame_mut<'a, 'frame>(frame: &'a mut Self::Frame<'frame>) -> &'a mut GlowFrame<'frame> {
fn glow_frame_mut<'a, 'frame, 'buffer>(
frame: &'a mut Self::Frame<'frame, 'buffer>,
) -> &'a mut GlowFrame<'frame, 'buffer> {
frame
}
}
@ -364,10 +372,14 @@ impl<'a> AsGlowRenderer for GlMultiRenderer<'a> {
fn glow_renderer_mut(&mut self) -> &mut GlowRenderer {
self.as_mut()
}
fn glow_frame<'b, 'frame>(frame: &'b Self::Frame<'frame>) -> &'b GlowFrame<'frame> {
fn glow_frame<'b, 'frame, 'buffer>(
frame: &'b Self::Frame<'frame, 'buffer>,
) -> &'b GlowFrame<'frame, 'buffer> {
frame.as_ref()
}
fn glow_frame_mut<'b, 'frame>(frame: &'b mut Self::Frame<'frame>) -> &'b mut GlowFrame<'frame> {
fn glow_frame_mut<'b, 'frame, 'buffer>(
frame: &'b mut Self::Frame<'frame, 'buffer>,
) -> &'b mut GlowFrame<'frame, 'buffer> {
frame.as_mut()
}
}
@ -415,12 +427,12 @@ impl Element for DamageElement {
impl<R: Renderer> RenderElement<R> for DamageElement {
fn draw(
&self,
_frame: &mut <R as Renderer>::Frame<'_>,
_frame: &mut R::Frame<'_, '_>,
_src: Rectangle<f64, BufferCoords>,
_dst: Rectangle<i32, Physical>,
_damage: &[Rectangle<i32, Physical>],
_opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), <R as Renderer>::Error> {
) -> Result<(), R::Error> {
Ok(())
}
}

102
src/backend/render/mod.rs
View file

@ -39,7 +39,6 @@ use smithay::{
allocator::dmabuf::Dmabuf,
drm::{DrmDeviceFd, DrmNode},
renderer::{
buffer_dimensions,
damage::{Error as RenderError, OutputDamageTracker, RenderOutputResult},
element::{
surface::{render_elements_from_surface_tree, WaylandSurfaceRenderElement},
@ -60,11 +59,7 @@ use smithay::{
input::Seat,
output::{Output, OutputNoMode},
utils::{IsAlive, Logical, Monotonic, Point, Rectangle, Scale, Time, Transform},
wayland::{
dmabuf::get_dmabuf,
session_lock::LockSurface,
shm::{shm_format_to_fourcc, with_buffer_contents},
},
wayland::{dmabuf::get_dmabuf, session_lock::LockSurface},
};
#[cfg(feature = "debug")]
@ -80,8 +75,8 @@ use super::kms::Timings;
pub type GlMultiRenderer<'a> =
MultiRenderer<'a, 'a, GbmGlowBackend<DrmDeviceFd>, GbmGlowBackend<DrmDeviceFd>>;
pub type GlMultiFrame<'a, 'frame> =
MultiFrame<'a, 'a, 'frame, GbmGlowBackend<DrmDeviceFd>, GbmGlowBackend<DrmDeviceFd>>;
pub type GlMultiFrame<'a, 'frame, 'buffer> =
MultiFrame<'a, 'a, 'frame, 'buffer, GbmGlowBackend<DrmDeviceFd>, GbmGlowBackend<DrmDeviceFd>>;
pub type GlMultiError = MultiError<GbmGlowBackend<DrmDeviceFd>, GbmGlowBackend<DrmDeviceFd>>;
pub enum RendererRef<'a> {
@ -414,7 +409,7 @@ pub fn cursor_elements<'a, 'frame, R>(
) -> Vec<CosmicElement<R>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
R::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
let scale = output.current_scale().fractional_scale();
@ -556,8 +551,8 @@ pub fn output_elements<R>(
) -> Result<Vec<CosmicElement<R>>, RenderError<R::Error>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
{
@ -647,11 +642,11 @@ pub fn workspace_elements<R>(
current: (WorkspaceHandle, usize),
cursor_mode: CursorMode,
element_filter: ElementFilter,
) -> Result<Vec<CosmicElement<R>>, RenderError<<R as Renderer>::Error>>
) -> Result<Vec<CosmicElement<R>>, RenderError<R::Error>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
{
@ -970,7 +965,7 @@ fn session_lock_elements<R>(
) -> Vec<WaylandSurfaceRenderElement<R>>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static,
R::TextureId: Clone + 'static,
{
if let Some(surface) = lock_surface {
let scale = Scale::from(output.current_scale().fractional_scale());
@ -988,33 +983,31 @@ where
}
#[profiling::function]
pub fn render_output<'d, R, Target, OffTarget>(
pub fn render_output<'d, R, OffTarget>(
gpu: Option<&DrmNode>,
renderer: &mut R,
target: Target,
target: &mut R::Framebuffer<'_>,
damage_tracker: &'d mut OutputDamageTracker,
age: usize,
shell: &Arc<RwLock<Shell>>,
now: Time<Monotonic>,
output: &Output,
cursor_mode: CursorMode,
) -> Result<RenderOutputResult<'d>, RenderError<<R as Renderer>::Error>>
) -> Result<RenderOutputResult<'d>, RenderError<R::Error>>
where
R: Renderer
+ ImportAll
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Bind<Target>
+ Offscreen<OffTarget>
+ Blit<Target>
+ Blit
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
Target: Clone,
{
let shell_ref = shell.read().unwrap();
let (previous_workspace, workspace) = shell_ref
@ -1038,7 +1031,7 @@ where
let result = render_workspace(
gpu,
renderer,
target.clone(),
target,
damage_tracker,
age,
None,
@ -1055,12 +1048,12 @@ where
match result {
Ok((res, mut elements)) => {
for (session, frame) in output.take_pending_frames() {
if let Some((frame, damage)) = render_session(
if let Some((frame, damage)) = render_session::<_, _, OffTarget>(
renderer,
&session.user_data().get::<SessionData>().unwrap(),
frame,
output.current_transform(),
|buffer, renderer, dt, age, additional_damage| {
|buffer, renderer, offscreen, dt, age, additional_damage| {
let old_len = if !additional_damage.is_empty() {
let area = output
.current_mode()
@ -1104,29 +1097,23 @@ where
if let (Some(ref damage), _) = &res {
if let Ok(dmabuf) = get_dmabuf(buffer) {
renderer
.bind(dmabuf.clone())
let mut dmabuf_clone = dmabuf.clone();
let mut fb = renderer
.bind(&mut dmabuf_clone)
.map_err(RenderError::Rendering)?;
for rect in damage.iter() {
renderer
.blit(target, &mut fb, *rect, *rect, TextureFilter::Nearest)
.map_err(RenderError::Rendering)?;
}
} else {
let size = buffer_dimensions(buffer).unwrap();
let format = with_buffer_contents(buffer, |_, _, data| {
shm_format_to_fourcc(data.format)
})
.map_err(|_| OutputNoMode)? // eh, we have to do some error
.expect(
"We should be able to convert all hardcoded shm screencopy formats",
);
let render_buffer = renderer
.create_buffer(format, size)
.map_err(RenderError::Rendering)?;
renderer
.bind(render_buffer)
.map_err(RenderError::Rendering)?;
}
for rect in damage.iter() {
renderer
.blit_from(target.clone(), *rect, *rect, TextureFilter::Nearest)
.map_err(RenderError::Rendering)?;
let fb =
offscreen.expect("shm buffers should have offscreen target");
for rect in damage.iter() {
renderer
.blit(target, fb, *rect, *rect, TextureFilter::Nearest)
.map_err(RenderError::Rendering)?;
}
}
}
@ -1148,10 +1135,10 @@ where
}
#[profiling::function]
pub fn render_workspace<'d, R, Target, OffTarget>(
pub fn render_workspace<'d, R>(
gpu: Option<&DrmNode>,
renderer: &mut R,
target: Target,
target: &mut R::Framebuffer<'_>,
damage_tracker: &'d mut OutputDamageTracker,
age: usize,
additional_damage: Option<Vec<Rectangle<i32, Logical>>>,
@ -1163,18 +1150,11 @@ pub fn render_workspace<'d, R, Target, OffTarget>(
current: (WorkspaceHandle, usize),
cursor_mode: CursorMode,
element_filter: ElementFilter,
) -> Result<(RenderOutputResult<'d>, Vec<CosmicElement<R>>), RenderError<<R as Renderer>::Error>>
) -> Result<(RenderOutputResult<'d>, Vec<CosmicElement<R>>), RenderError<R::Error>>
where
R: Renderer
+ ImportAll
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Bind<Target>
+ Offscreen<OffTarget>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R: Renderer + ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
@ -1203,9 +1183,9 @@ where
);
}
renderer.bind(target).map_err(RenderError::Rendering)?;
let res = damage_tracker.render_output(
renderer,
target,
age,
&elements,
CLEAR_COLOR, // TODO use a theme neutral color