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

4
src/backend/kms/render/gles.rs
View file

@ -11,7 +11,7 @@ use smithay::backend::{
gles::GlesError,
glow::GlowRenderer,
multigpu::{ApiDevice, Error as MultiError, GraphicsApi},
Renderer,
RendererSuper,
},
SwapBuffersError,
};
@ -182,7 +182,7 @@ impl ApiDevice for GbmGlowDevice {
impl<T: GraphicsApi, A: AsFd + Clone + 'static> FromGlesError for MultiError<GbmGlowBackend<A>, T>
where
T::Error: 'static,
<<T::Device as ApiDevice>::Renderer as Renderer>::Error: 'static,
<<T::Device as ApiDevice>::Renderer as RendererSuper>::Error: 'static,
{
#[inline]
fn from_gles_error(err: GlesError) -> MultiError<GbmGlowBackend<A>, T> {

99
src/backend/kms/surface/mod.rs
View file

@ -45,7 +45,7 @@ use smithay::{
multigpu::{Error as MultiError, GpuManager},
sync::SyncPoint,
utils::with_renderer_surface_state,
Bind, ImportDma, Offscreen, Renderer, Texture,
Bind, ImportDma, Offscreen, Renderer, RendererSuper, Texture,
},
},
desktop::utils::OutputPresentationFeedback,
@ -93,13 +93,6 @@ use super::{drm_helpers, render::gles::GbmGlowBackend};
#[cfg(feature = "debug")]
use smithay_egui::EguiState;
#[cfg(feature = "debug")]
static INTEL_LOGO: &'static [u8] = include_bytes!("../../../../resources/icons/intel.svg");
#[cfg(feature = "debug")]
static AMD_LOGO: &'static [u8] = include_bytes!("../../../../resources/icons/amd.svg");
#[cfg(feature = "debug")]
static NVIDIA_LOGO: &'static [u8] = include_bytes!("../../../../resources/icons/nvidia.svg");
#[derive(Debug)]
pub struct Surface {
pub(crate) connector: connector::Handle,
@ -740,19 +733,6 @@ impl SurfaceThreadState {
unsafe { GlowRenderer::new(egl) }.context("Failed to create renderer")?;
init_shaders(renderer.borrow_mut()).context("Failed to initialize shaders")?;
#[cfg(feature = "debug")]
{
self.egui
.load_svg(&mut renderer, String::from("intel"), INTEL_LOGO)
.unwrap();
self.egui
.load_svg(&mut renderer, String::from("amd"), AMD_LOGO)
.unwrap();
self.egui
.load_svg(&mut renderer, String::from("nvidia"), NVIDIA_LOGO)
.unwrap();
}
self.api.as_mut().add_node(node, gbm, renderer);
/*
} else {
@ -1107,10 +1087,11 @@ impl SurfaceThreadState {
mirroring_state
.texture
.render()
.draw::<_, <GlMultiRenderer as Renderer>::Error>(|tex| {
let res = match mirroring_state.damage_tracker.render_output_with(
.draw::<_, <GlMultiRenderer as RendererSuper>::Error>(|tex| {
let mut fb = renderer.bind(tex)?;
let res = match mirroring_state.damage_tracker.render_output(
&mut renderer,
tex.clone(),
&mut fb,
1,
&elements,
CLEAR_COLOR,
@ -1119,8 +1100,8 @@ impl SurfaceThreadState {
Err(RenderError::Rendering(err)) => return Err(err),
Err(RenderError::OutputNoMode(_)) => unreachable!(),
};
renderer.wait(&res.sync)?;
std::mem::drop(fb);
let transform = mirrored_output.current_transform();
let area = tex.size().to_logical(1, transform);
@ -1235,34 +1216,39 @@ impl SurfaceThreadState {
let mut sync = SyncPoint::default();
if let Some(ref damage) = damage {
let buffer = frame.buffer();
if let Ok(dmabuf) = get_dmabuf(&buffer) {
renderer
.bind(dmabuf.clone())
.map_err(RenderError::<<GlMultiRenderer as Renderer>::Error>::Rendering)?;
} else {
let size = buffer_dimensions(&buffer).ok_or(RenderError::<
<GlMultiRenderer as Renderer>::Error,
>::Rendering(
MultiError::ImportFailed,
))?;
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 =
Offscreen::<GlesRenderbuffer>::create_buffer(
&mut renderer,
format,
size,
)
.map_err(RenderError::<<GlMultiRenderer as Renderer>::Error>::Rendering)?;
renderer
.bind(render_buffer)
.map_err(RenderError::<<GlMultiRenderer as Renderer>::Error>::Rendering)?;
}
let mut dmabuf_clone;
let mut render_buffer;
let buffer = frame.buffer();
let mut shm_buffer = false;
let mut fb = if let Ok(dmabuf) = get_dmabuf(&buffer) {
dmabuf_clone = dmabuf.clone();
renderer
.bind(&mut dmabuf_clone)
.map_err(RenderError::<<GlMultiRenderer as RendererSuper>::Error>::Rendering)?
} else {
shm_buffer = true;
let size = buffer_dimensions(&buffer).ok_or(RenderError::<
<GlMultiRenderer as RendererSuper>::Error,
>::Rendering(
MultiError::ImportFailed,
))?;
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");
render_buffer =
Offscreen::<GlesRenderbuffer>::create_buffer(
&mut renderer,
format,
size,
)
.map_err(RenderError::<<GlMultiRenderer as RendererSuper>::Error>::Rendering)?;
renderer
.bind(&mut render_buffer)
.map_err(RenderError::<<GlMultiRenderer as RendererSuper>::Error>::Rendering)?
};
if let Some(ref damage) = damage {
let (output_size, output_scale, output_transform) = (
self.output.current_mode().ok_or(OutputNoMode)?.size,
self.output.current_scale().fractional_scale(),
@ -1292,23 +1278,25 @@ impl SurfaceThreadState {
.to_physical(1);
d
});
match frame_result
.blit_frame_result(
output_size,
output_transform,
output_scale,
&mut renderer,
&mut fb,
adjusted,
filter,
)
.map_err(|err| match err {
BlitFrameResultError::Rendering(err) => RenderError::<
<GlMultiRenderer as Renderer>::Error,
<GlMultiRenderer as RendererSuper>::Error,
>::Rendering(
err
),
BlitFrameResultError::Export(_) => RenderError::<
<GlMultiRenderer as Renderer>::Error,
<GlMultiRenderer as RendererSuper>::Error,
>::Rendering(
MultiError::DeviceMissing,
),
@ -1329,13 +1317,14 @@ impl SurfaceThreadState {
continue;
}
};
}
};
let transform = self.output.current_transform();
match submit_buffer(
frame,
&mut renderer,
shm_buffer.then_some(&mut fb),
transform,
damage.as_deref(),
sync,

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

17
src/backend/winit.rs
View file

@ -47,16 +47,15 @@ pub struct WinitState {
impl WinitState {
#[profiling::function]
pub fn render_output(&mut self, state: &mut Common) -> Result<()> {
self.backend
let age = self.backend.buffer_age().unwrap_or(0);
let (renderer, mut fb) = self
.backend
.bind()
.with_context(|| "Failed to bind buffer")?;
let age = self.backend.buffer_age().unwrap_or(0);
let surface = self.backend.egl_surface();
match render::render_output::<_, _, GlesRenderbuffer>(
match render::render_output::<_, GlesRenderbuffer>(
None,
self.backend.renderer(),
surface.clone(),
renderer,
&mut fb,
&mut self.damage_tracker,
age,
&state.shell,
@ -65,9 +64,7 @@ impl WinitState {
CursorMode::NotDefault,
) {
Ok(RenderOutputResult { damage, states, .. }) => {
self.backend
.bind()
.with_context(|| "Failed to bind display")?;
std::mem::drop(fb);
self.backend
.submit(damage.map(|x| x.as_slice()))
.with_context(|| "Failed to submit buffer for display")?;

9
src/backend/x11.rs
View file

@ -202,14 +202,17 @@ pub struct Surface {
impl Surface {
pub fn render_output(&mut self, renderer: &mut GlowRenderer, state: &mut Common) -> Result<()> {
let (buffer, age) = self
let (mut buffer, age) = self
.surface
.buffer()
.with_context(|| "Failed to allocate buffer")?;
match render::render_output::<_, _, GlesRenderbuffer>(
let mut fb = renderer
.bind(&mut buffer)
.with_context(|| "Failed to bind dmabuf")?;
match render::render_output::<_, GlesRenderbuffer>(
None,
renderer,
buffer.clone(),
&mut fb,
&mut self.damage_tracker,
age as usize,
&state.shell,