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

chore: Update smithay

Browse source
This commit is contained in:
Victoria Brekenfeld 2023-03-31 14:04:47 +02:00
parent bb59a2d437
commit 636d38921a
7 changed files with 76 additions and 103 deletions
Download patch file Download diff file Expand all files Collapse all files

18
Cargo.lock generated
View file

@ -757,9 +757,9 @@ checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
[[package]] [[package]]
name = "drm" name = "drm"
version = "0.8.0" version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "98d190a8cb219483212f462d9e34abebe24a13cdb7f0c9a64c5b59175ccd62d2" checksum = "edf9159ef4bcecd0c5e4cbeb573b8d0037493403d542780dba5d840bbf9df56f"
dependencies = [ dependencies = [
"bitflags", "bitflags",
"bytemuck", "bytemuck",
@ -770,9 +770,9 @@ dependencies = [
[[package]] [[package]]
name = "drm-ffi" name = "drm-ffi"
version = "0.4.0" version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "48310b65d262ac1140f63e2bbc605c73a417c7e46452ea8c20a3cad698af96d0" checksum = "1352481b7b90e27a8a1bf8ef6b33cf18b98dba7c410e75c24bb3eef2f0d8d525"
dependencies = [ dependencies = [
"drm-sys", "drm-sys",
"nix 0.26.2", "nix 0.26.2",
@ -786,9 +786,9 @@ checksum = "0aafbcdb8afc29c1a7ee5fbe53b5d62f4565b35a042a662ca9fecd0b54dae6f4"
[[package]] [[package]]
name = "drm-sys" name = "drm-sys"
version = "0.3.0" version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "52ecd1ca96a64fd7444a58a2ce3aa8be79cea3c1c7f7f69a4b89624018b46377" checksum = "1369f1679d6b706d234c4c1e0613c415c2c74b598a09ad28080ba2474b72e42d"
dependencies = [ dependencies = [
"libc", "libc",
] ]
@ -1265,9 +1265,9 @@ dependencies = [
[[package]] [[package]]
name = "gbm" name = "gbm"
version = "0.11.0" version = "0.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fffcdb4a9a42ceeb8170a916a84d44ec1fbfbbd753070180a98db92b71bfd431" checksum = "f2ec389cda876966cf824111bf6e533fb934c711d473498279964a990853b3c6"
dependencies = [ dependencies = [
"bitflags", "bitflags",
"drm", "drm",
@ -3306,7 +3306,7 @@ checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
[[package]] [[package]]
name = "smithay" name = "smithay"
version = "0.3.0" version = "0.3.0"
source = "git+https://github.com/pop-os/smithay?rev=4e287a585a#4e287a585ae257393a0377694b2d284da243f4b2" source = "git+https://github.com/smithay//smithay?rev=a5a3c2bd4e#a5a3c2bd4e129e6895e1884b075a9994c9affe66"
dependencies = [ dependencies = [
"appendlist", "appendlist",
"ash", "ash",

2
Cargo.toml
View file

@ -70,4 +70,4 @@ debug = true
lto = "fat" lto = "fat"
[patch."https://github.com/Smithay/smithay.git"] [patch."https://github.com/Smithay/smithay.git"]
smithay = { git = "https://github.com/pop-os/smithay", rev = "4e287a585a" } smithay = { git = "https://github.com/smithay//smithay", rev = "a5a3c2bd4e" }

6
src/backend/kms/mod.rs
View file

@ -33,7 +33,7 @@ use smithay::{
libinput::{LibinputInputBackend, LibinputSessionInterface}, libinput::{LibinputInputBackend, LibinputSessionInterface},
renderer::{ renderer::{
buffer_dimensions, buffer_dimensions,
damage::{DamageTrackedRendererError as RenderError, OutputNoMode}, damage::{Error as RenderError, OutputNoMode},
gles2::Gles2Renderbuffer, gles2::Gles2Renderbuffer,
glow::GlowRenderer, glow::GlowRenderer,
multigpu::{gbm::GbmGlesBackend, Error as MultiError, GpuManager}, multigpu::{gbm::GbmGlesBackend, Error as MultiError, GpuManager},
@ -1013,8 +1013,8 @@ impl Surface {
&session, &session,
params, params,
self.output.current_transform(), self.output.current_transform(),
|_node, buffer, renderer, dtr, age| { |_node, buffer, renderer, dt, age| {
let res = dtr.damage_output(age, &elements)?; let res = dt.damage_output(age, &elements)?;
if let (Some(ref damage), _) = &res { if let (Some(ref damage), _) = &res {
if let Ok(dmabuf) = get_dmabuf(buffer) { if let Ok(dmabuf) = get_dmabuf(buffer) {

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

@ -35,9 +35,7 @@ use smithay::{
drm::DrmNode, drm::DrmNode,
renderer::{ renderer::{
buffer_dimensions, buffer_dimensions,
damage::{ damage::{Error as RenderError, OutputDamageTracker, OutputNoMode},
DamageTrackedRenderer, DamageTrackedRendererError as RenderError, OutputNoMode,
},
element::{Element, RenderElement, RenderElementStates}, element::{Element, RenderElement, RenderElementStates},
gles2::{ gles2::{
element::PixelShaderElement, Gles2Error, Gles2PixelProgram, Gles2Renderer, Uniform, element::PixelShaderElement, Gles2Error, Gles2PixelProgram, Gles2Renderer, Uniform,
@ -316,7 +314,7 @@ pub fn render_output<'frame, R, Target, OffTarget, Source>(
gpu: Option<&DrmNode>, gpu: Option<&DrmNode>,
renderer: &mut R, renderer: &mut R,
target: Target, target: Target,
damage_tracker: &mut DamageTrackedRenderer, damage_tracker: &mut OutputDamageTracker,
age: usize, age: usize,
state: &mut Common, state: &mut Common,
output: &Output, output: &Output,
@ -364,7 +362,7 @@ pub fn render_workspace<'frame, R, Target, OffTarget, Source>(
gpu: Option<&DrmNode>, gpu: Option<&DrmNode>,
renderer: &mut R, renderer: &mut R,
target: Target, target: Target,
damage_tracker: &mut DamageTrackedRenderer, damage_tracker: &mut OutputDamageTracker,
age: usize, age: usize,
state: &mut Common, state: &mut Common,
output: &Output, output: &Output,
@ -450,8 +448,8 @@ where
&session, &session,
params, params,
output.current_transform(), output.current_transform(),
|_node, buffer, renderer, dtr, age| { |_node, buffer, renderer, dt, age| {
let res = dtr.damage_output(age, &elements)?; let res = dt.damage_output(age, &elements)?;
if let (Some(ref damage), _) = &res { if let (Some(ref damage), _) = &res {
if let Ok(dmabuf) = get_dmabuf(buffer) { if let Ok(dmabuf) = get_dmabuf(buffer) {

6
src/backend/winit.rs
View file

@ -13,7 +13,7 @@ use smithay::{
backend::{ backend::{
egl::EGLDevice, egl::EGLDevice,
renderer::{ renderer::{
damage::DamageTrackedRenderer, gles2::Gles2Renderbuffer, glow::GlowRenderer, ImportDma, damage::OutputDamageTracker, gles2::Gles2Renderbuffer, glow::GlowRenderer, ImportDma,
ImportEgl, ImportEgl,
}, },
winit::{self, WinitEvent, WinitGraphicsBackend, WinitVirtualDevice}, winit::{self, WinitEvent, WinitGraphicsBackend, WinitVirtualDevice},
@ -40,7 +40,7 @@ pub struct WinitState {
// The winit backend currently has no notion of multiple windows // The winit backend currently has no notion of multiple windows
pub backend: WinitGraphicsBackend<GlowRenderer>, pub backend: WinitGraphicsBackend<GlowRenderer>,
output: Output, output: Output,
damage_tracker: DamageTrackedRenderer, damage_tracker: OutputDamageTracker,
screencopy: Vec<(ScreencopySession, BufferParams)>, screencopy: Vec<(ScreencopySession, BufferParams)>,
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
fps: Fps, fps: Fps,
@ -240,7 +240,7 @@ pub fn init_backend(
state.backend = BackendData::Winit(WinitState { state.backend = BackendData::Winit(WinitState {
backend, backend,
output: output.clone(), output: output.clone(),
damage_tracker: DamageTrackedRenderer::from_output(&output), damage_tracker: OutputDamageTracker::from_output(&output),
screencopy: Vec::new(), screencopy: Vec::new(),
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
fps, fps,

6
src/backend/x11.rs
View file

@ -20,7 +20,7 @@ use smithay::{
egl::{EGLContext, EGLDevice, EGLDisplay}, egl::{EGLContext, EGLDevice, EGLDisplay},
input::{Event, InputEvent}, input::{Event, InputEvent},
renderer::{ renderer::{
damage::DamageTrackedRenderer, gles2::Gles2Renderbuffer, glow::GlowRenderer, Bind, damage::OutputDamageTracker, gles2::Gles2Renderbuffer, glow::GlowRenderer, Bind,
ImportDma, ImportEgl, ImportDma, ImportEgl,
}, },
vulkan::{version::Version, Instance, PhysicalDevice}, vulkan::{version::Version, Instance, PhysicalDevice},
@ -141,7 +141,7 @@ impl X11State {
self.surfaces.push(Surface { self.surfaces.push(Surface {
window, window,
surface, surface,
damage_tracker: DamageTrackedRenderer::from_output(&output), damage_tracker: OutputDamageTracker::from_output(&output),
output: output.clone(), output: output.clone(),
render: ping.clone(), render: ping.clone(),
dirty: false, dirty: false,
@ -204,7 +204,7 @@ impl X11State {
pub struct Surface { pub struct Surface {
window: Window, window: Window,
damage_tracker: DamageTrackedRenderer, damage_tracker: OutputDamageTracker,
screencopy: Vec<(ScreencopySession, BufferParams)>, screencopy: Vec<(ScreencopySession, BufferParams)>,
surface: X11Surface, surface: X11Surface,
output: Output, output: Output,

129
src/wayland/handlers/screencopy.rs
View file

@ -16,7 +16,7 @@ use smithay::{
egl::EGLDevice, egl::EGLDevice,
renderer::{ renderer::{
buffer_dimensions, buffer_type, buffer_dimensions, buffer_type,
damage::{DamageTrackedRenderer, DamageTrackedRendererError}, damage::{Error as DTError, OutputDamageTracker},
element::{ element::{
surface::WaylandSurfaceRenderElement, AsRenderElements, RenderElement, surface::WaylandSurfaceRenderElement, AsRenderElements, RenderElement,
RenderElementStates, RenderElementStates,
@ -92,7 +92,7 @@ impl PartialEq<Session> for DropableSession {
} }
} }
pub type SessionDTR = RefCell<DamageTrackedRenderer>; pub type SessionDT = RefCell<OutputDamageTracker>;
impl ScreencopyHandler for State { impl ScreencopyHandler for State {
fn capture_output(&mut self, output: Output, session: Session) -> Vec<BufferInfo> { fn capture_output(&mut self, output: Output, session: Session) -> Vec<BufferInfo> {
@ -117,7 +117,7 @@ impl ScreencopyHandler for State {
session session
.user_data() .user_data()
.insert_if_missing(|| SessionDTR::new(DamageTrackedRenderer::from_output(&output))); .insert_if_missing(|| SessionDT::new(OutputDamageTracker::from_output(&output)));
output output
.user_data() .user_data()
.insert_if_missing(ScreencopySessions::default); .insert_if_missing(ScreencopySessions::default);
@ -156,7 +156,7 @@ impl ScreencopyHandler for State {
session session
.user_data() .user_data()
.insert_if_missing(|| SessionDTR::new(DamageTrackedRenderer::from_output(&output))); .insert_if_missing(|| SessionDT::new(OutputDamageTracker::from_output(&output)));
workspace workspace
.screencopy_sessions .screencopy_sessions
@ -226,7 +226,7 @@ impl ScreencopyHandler for State {
let size = toplevel.geometry().size.to_physical(1); let size = toplevel.geometry().size.to_physical(1);
session.user_data().insert_if_missing(|| { session.user_data().insert_if_missing(|| {
SessionDTR::new(DamageTrackedRenderer::new(size, 1.0, Transform::Normal)) SessionDT::new(OutputDamageTracker::new(size, 1.0, Transform::Normal))
}); });
toplevel toplevel
.user_data() .user_data()
@ -547,40 +547,34 @@ pub fn render_session<F, R>(
params: &BufferParams, params: &BufferParams,
transform: Transform, transform: Transform,
render_fn: F, render_fn: F,
) -> Result<bool, DamageTrackedRendererError<R>> ) -> Result<bool, DTError<R>>
where where
R: ExportMem, R: ExportMem,
F: FnOnce( F: FnOnce(
Option<&DrmNode>, Option<&DrmNode>,
&WlBuffer, &WlBuffer,
&mut R, &mut R,
&mut DamageTrackedRenderer, &mut OutputDamageTracker,
usize, usize,
) -> Result< )
(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), DTError<R>>,
DamageTrackedRendererError<R>,
>,
{ {
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
puffin::profile_function!(); puffin::profile_function!();
let mut dtr = session let mut dt = session.user_data().get::<SessionDT>().unwrap().borrow_mut();
.user_data()
.get::<SessionDTR>()
.unwrap()
.borrow_mut();
let res = render_fn( let res = render_fn(
node.as_ref(), node.as_ref(),
&params.buffer, &params.buffer,
renderer, renderer,
&mut *dtr, &mut *dt,
params.age as usize, params.age as usize,
)?; )?;
if let (Some(damage), _) = res { if let (Some(damage), _) = res {
submit_buffer(session, &params.buffer, renderer, transform, damage) submit_buffer(session, &params.buffer, renderer, transform, damage)
.map_err(DamageTrackedRendererError::Rendering)?; .map_err(DTError::Rendering)?;
Ok(true) Ok(true)
} else { } else {
Ok(false) Ok(false)
@ -605,15 +599,12 @@ pub fn render_output_to_buffer(
node: Option<&DrmNode>, node: Option<&DrmNode>,
buffer: &WlBuffer, buffer: &WlBuffer,
renderer: &mut R, renderer: &mut R,
dtr: &mut DamageTrackedRenderer, dt: &mut OutputDamageTracker,
age: usize, age: usize,
common: &mut Common, common: &mut Common,
session: &Session, session: &Session,
output: &Output, output: &Output,
) -> Result< ) -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), DTError<R>>
(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates),
DamageTrackedRendererError<R>,
>
where where
R: Renderer R: Renderer
+ ImportAll + ImportAll
@ -639,7 +630,7 @@ pub fn render_output_to_buffer(
node, node,
renderer, renderer,
dmabuf, dmabuf,
dtr, dt,
age, age,
common, common,
&output, &output,
@ -650,12 +641,12 @@ pub fn render_output_to_buffer(
} else { } else {
let size = buffer_dimensions(buffer).unwrap(); let size = buffer_dimensions(buffer).unwrap();
let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size) let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size)
.map_err(DamageTrackedRendererError::Rendering)?; .map_err(DTError::Rendering)?;
render_output::<_, _, Gles2Renderbuffer, Dmabuf>( render_output::<_, _, Gles2Renderbuffer, Dmabuf>(
node, node,
renderer, renderer,
render_buffer, render_buffer,
dtr, dt,
age, age,
common, common,
&output, &output,
@ -680,13 +671,13 @@ pub fn render_output_to_buffer(
session, session,
&params, &params,
output.current_transform(), output.current_transform(),
|node, buffer, renderer, dtr, age| { |node, buffer, renderer, dt, age| {
render_fn(node, buffer, renderer, dtr, age, common, session, output) render_fn(node, buffer, renderer, dt, age, common, session, output)
}, },
) )
.map_err(|err| match err { .map_err(|err| match err {
DamageTrackedRendererError::OutputNoMode(x) => (FailureReason::Unspec, x.into()), DTError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
DamageTrackedRendererError::Rendering(x) => (FailureReason::Unspec, x.into()), DTError::Rendering(x) => (FailureReason::Unspec, x.into()),
}) })
} }
BackendData::Winit(winit) => render_session::<_, _>( BackendData::Winit(winit) => render_session::<_, _>(
@ -695,8 +686,8 @@ pub fn render_output_to_buffer(
session, session,
&params, &params,
output.current_transform(), output.current_transform(),
|node, buffer, renderer, dtr, age| { |node, buffer, renderer, dt, age| {
render_fn(node, buffer, renderer, dtr, age, common, session, output) render_fn(node, buffer, renderer, dt, age, common, session, output)
}, },
) )
.map_err(|err| (FailureReason::Unspec, err.into())), .map_err(|err| (FailureReason::Unspec, err.into())),
@ -706,8 +697,8 @@ pub fn render_output_to_buffer(
session, session,
&params, &params,
output.current_transform(), output.current_transform(),
|node, buffer, renderer, dtr, age| { |node, buffer, renderer, dt, age| {
render_fn(node, buffer, renderer, dtr, age, common, session, output) render_fn(node, buffer, renderer, dt, age, common, session, output)
}, },
) )
.map_err(|err| (FailureReason::Unspec, err.into())), .map_err(|err| (FailureReason::Unspec, err.into())),
@ -734,16 +725,13 @@ pub fn render_workspace_to_buffer(
node: Option<&DrmNode>, node: Option<&DrmNode>,
buffer: &WlBuffer, buffer: &WlBuffer,
renderer: &mut R, renderer: &mut R,
dtr: &mut DamageTrackedRenderer, dt: &mut OutputDamageTracker,
age: usize, age: usize,
common: &mut Common, common: &mut Common,
session: &Session, session: &Session,
output: &Output, output: &Output,
handle: &WorkspaceHandle, handle: &WorkspaceHandle,
) -> Result< ) -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), DTError<R>>
(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates),
DamageTrackedRendererError<R>,
>
where where
R: Renderer R: Renderer
+ ImportAll + ImportAll
@ -768,7 +756,7 @@ pub fn render_workspace_to_buffer(
node, node,
renderer, renderer,
dmabuf, dmabuf,
dtr, dt,
age, age,
common, common,
&output, &output,
@ -781,12 +769,12 @@ pub fn render_workspace_to_buffer(
} else { } else {
let size = buffer_dimensions(buffer).unwrap(); let size = buffer_dimensions(buffer).unwrap();
let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size) let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size)
.map_err(DamageTrackedRendererError::Rendering)?; .map_err(DTError::Rendering)?;
render_workspace::<_, _, Gles2Renderbuffer, Dmabuf>( render_workspace::<_, _, Gles2Renderbuffer, Dmabuf>(
node, node,
renderer, renderer,
render_buffer, render_buffer,
dtr, dt,
age, age,
common, common,
&output, &output,
@ -813,15 +801,15 @@ pub fn render_workspace_to_buffer(
session, session,
&params, &params,
output.current_transform(), output.current_transform(),
|node, buffer, renderer, dtr, age| { |node, buffer, renderer, dt, age| {
render_fn( render_fn(
node, buffer, renderer, dtr, age, common, session, output, handle, node, buffer, renderer, dt, age, common, session, output, handle,
) )
}, },
) )
.map_err(|err| match err { .map_err(|err| match err {
DamageTrackedRendererError::OutputNoMode(x) => (FailureReason::Unspec, x.into()), DTError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
DamageTrackedRendererError::Rendering(x) => (FailureReason::Unspec, x.into()), DTError::Rendering(x) => (FailureReason::Unspec, x.into()),
}) })
} }
BackendData::Winit(winit) => render_session::<_, _>( BackendData::Winit(winit) => render_session::<_, _>(
@ -830,9 +818,9 @@ pub fn render_workspace_to_buffer(
session, session,
&params, &params,
output.current_transform(), output.current_transform(),
|node, buffer, renderer, dtr, age| { |node, buffer, renderer, dt, age| {
render_fn( render_fn(
node, buffer, renderer, dtr, age, common, session, output, handle, node, buffer, renderer, dt, age, common, session, output, handle,
) )
}, },
) )
@ -843,9 +831,9 @@ pub fn render_workspace_to_buffer(
session, session,
&params, &params,
output.current_transform(), output.current_transform(),
|node, buffer, renderer, dtr, age| { |node, buffer, renderer, dt, age| {
render_fn( render_fn(
node, buffer, renderer, dtr, age, common, session, output, handle, node, buffer, renderer, dt, age, common, session, output, handle,
) )
}, },
) )
@ -878,16 +866,13 @@ pub fn render_window_to_buffer(
fn render_fn<R>( fn render_fn<R>(
buffer: &WlBuffer, buffer: &WlBuffer,
renderer: &mut R, renderer: &mut R,
dtr: &mut DamageTrackedRenderer, dt: &mut OutputDamageTracker,
age: usize, age: usize,
session: &Session, session: &Session,
common: &mut Common, common: &mut Common,
window: &CosmicSurface, window: &CosmicSurface,
geometry: Rectangle<i32, Logical>, geometry: Rectangle<i32, Logical>,
) -> Result< ) -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), DTError<R>>
(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates),
DamageTrackedRendererError<R>,
>
where where
R: Renderer R: Renderer
+ ImportAll + ImportAll
@ -952,19 +937,15 @@ pub fn render_window_to_buffer(
} }
if let Ok(dmabuf) = get_dmabuf(buffer) { if let Ok(dmabuf) = get_dmabuf(buffer) {
renderer renderer.bind(dmabuf).map_err(DTError::Rendering)?;
.bind(dmabuf)
.map_err(DamageTrackedRendererError::Rendering)?;
} else { } else {
let size = buffer_dimensions(buffer).unwrap(); let size = buffer_dimensions(buffer).unwrap();
let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size) let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size)
.map_err(DamageTrackedRendererError::Rendering)?; .map_err(DTError::Rendering)?;
renderer renderer.bind(render_buffer).map_err(DTError::Rendering)?;
.bind(render_buffer)
.map_err(DamageTrackedRendererError::Rendering)?;
} }
dtr.render_output(renderer, age, &elements, CLEAR_COLOR) dt.render_output(renderer, age, &elements, CLEAR_COLOR)
} }
let node = node_from_params(&params, &mut state.backend, None); let node = node_from_params(&params, &mut state.backend, None);
@ -981,15 +962,13 @@ pub fn render_window_to_buffer(
session, session,
&params, &params,
Transform::Normal, Transform::Normal,
|_node, buffer, renderer, dtr, age| { |_node, buffer, renderer, dt, age| {
render_fn( render_fn(buffer, renderer, dt, age, session, common, window, geometry)
buffer, renderer, dtr, age, session, common, window, geometry,
)
}, },
) )
.map_err(|err| match err { .map_err(|err| match err {
DamageTrackedRendererError::OutputNoMode(x) => (FailureReason::Unspec, x.into()), DTError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
DamageTrackedRendererError::Rendering(x) => (FailureReason::Unspec, x.into()), DTError::Rendering(x) => (FailureReason::Unspec, x.into()),
}) })
} }
BackendData::Winit(winit) => render_session::<_, _>( BackendData::Winit(winit) => render_session::<_, _>(
@ -998,10 +977,8 @@ pub fn render_window_to_buffer(
session, session,
&params, &params,
Transform::Normal, Transform::Normal,
|_node, buffer, renderer, dtr, age| { |_node, buffer, renderer, dt, age| {
render_fn( render_fn(buffer, renderer, dt, age, session, common, window, geometry)
buffer, renderer, dtr, age, session, common, window, geometry,
)
}, },
) )
.map_err(|err| (FailureReason::Unspec, err.into())), .map_err(|err| (FailureReason::Unspec, err.into())),
@ -1011,10 +988,8 @@ pub fn render_window_to_buffer(
session, session,
&params, &params,
Transform::Normal, Transform::Normal,
|_node, buffer, renderer, dtr, age| { |_node, buffer, renderer, dt, age| {
render_fn( render_fn(buffer, renderer, dt, age, session, common, window, geometry)
buffer, renderer, dtr, age, session, common, window, geometry,
)
}, },
) )
.map_err(|err| (FailureReason::Unspec, err.into())), .map_err(|err| (FailureReason::Unspec, err.into())),