Epsilon_02/niri
1
0
Fork 0
mirror of https://github.com/YaLTeR/niri.git synced 2025-10-06 00:23:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

Update Smithay (Framebuffer type)

Browse Source
This commit is contained in:
Ivan Molodetskikh
2025-03-09 22:03:14 +03:00
parent eda43b2b93
commit 1c521e4831
20 changed files with 138 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
Cargo.lock generated
View File

@@ -30,6 +30,12 @@ dependencies = [
"memchr",
]
[[package]]
name = "aliasable"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
[[package]]
name = "allocator-api2"
version = "0.2.21"
@@ -3360,8 +3366,9 @@ checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
[[package]]
name = "smithay"
version = "0.5.0"
source = "git+https://github.com/Smithay/smithay.git#25cf3cf41c5027ffeb55f90c683736726a81d71f"
source = "git+https://github.com/Smithay/smithay.git#3219a0f02a30de359f460ab165682a51cb13b7a5"
dependencies = [
"aliasable",
"appendlist",
"bitflags 2.9.0",
"calloop 0.14.2",
@@ -3431,7 +3438,7 @@ dependencies = [
[[package]]
name = "smithay-drm-extras"
version = "0.1.0"
source = "git+https://github.com/Smithay/smithay.git#25cf3cf41c5027ffeb55f90c683736726a81d71f"
source = "git+https://github.com/Smithay/smithay.git#3219a0f02a30de359f460ab165682a51cb13b7a5"
dependencies = [
"drm",
"libdisplay-info",

96
niri-visual-tests/src/smithay_view.rs
View File

@@ -17,19 +17,25 @@ mod imp {
use niri::render_helpers::{resources, shaders};
use smithay::backend::egl::ffi::egl;
use smithay::backend::egl::EGLContext;
use smithay::backend::renderer::gles::GlesRenderer;
use smithay::backend::renderer::{Color32F, Frame, Renderer, Unbind};
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::{Physical, Rectangle, Scale, Transform};
use super::*;
type DynMakeTestCase = Box<dyn Fn(Args) -> Box<dyn TestCase>>;
struct RendererData {
renderer: GlesRenderer,
dummy_texture: GlesTexture,
}
#[derive(Default)]
pub struct SmithayView {
gl_area: gtk::GLArea,
size: Cell<(i32, i32)>,
renderer: RefCell<Option<Result<GlesRenderer, ()>>>,
renderer: RefCell<Option<Result<RendererData, ()>>>,
pub make_test_case: OnceCell<DynMakeTestCase>,
test_case: RefCell<Option<Box<dyn TestCase>>>,
pub clock: RefCell<Clock>,
@@ -125,6 +131,10 @@ mod imp {
let Ok(renderer) = renderer else {
return Ok(());
};
let RendererData {
renderer,
dummy_texture,
} = renderer;
let size = self.size.get();
@@ -147,16 +157,45 @@ mod imp {
let rect: Rectangle<i32, Physical> = Rectangle::from_size(Size::from(size));
let elements = unsafe {
with_framebuffer_save_restore(renderer, |renderer| {
case.render(renderer, Size::from(size))
// Fetch GtkGLArea's framebuffer binding.
let mut framebuffer = 0;
renderer
.with_context(|gl| unsafe {
gl.GetIntegerv(
smithay::backend::renderer::gles::ffi::FRAMEBUFFER_BINDING,
&mut framebuffer,
);
})
}?;
.context("error running closure in GL context")?;
ensure!(framebuffer != 0, "error getting the framebuffer");
// This call will already change the framebuffer binding (offscreen elements will bind
// intermediate textures during rendering).
let elements = case.render(renderer, Size::from(size));
// HACK: there's currently no way to "just" render into an externally bound framebuffer
// (like we have in this case). The render() call requires a valid target. So what
// we'll do is use a dummy texture as a target, then swap the framebuffer binding right
// before rendering.
let mut dummy_target = renderer
.bind(dummy_texture)
.context("error binding dummy texture")?;
let mut frame = renderer
.render(rect.size, Transform::Normal)
.render(&mut dummy_target, rect.size, Transform::Normal)
.context("error creating frame")?;
// Now that render() bound the dummy texture, change the binding underneath it back to
// GtkGLArea's framebuffer, to render there instead.
frame
.with_context(|gl| unsafe {
gl.BindFramebuffer(
smithay::backend::renderer::gles::ffi::FRAMEBUFFER,
framebuffer as u32,
);
})
.context("error running closure in GL context")?;
frame
.clear(Color32F::from([0.3, 0.3, 0.3, 1.]), &[rect])
.context("error clearing")?;
@@ -177,7 +216,7 @@ mod imp {
}
}
unsafe fn create_renderer() -> anyhow::Result<GlesRenderer> {
unsafe fn create_renderer() -> anyhow::Result<RendererData> {
smithay::backend::egl::ffi::make_sure_egl_is_loaded()
.context("error loading EGL symbols in Smithay")?;
@@ -200,40 +239,17 @@ mod imp {
let mut renderer = GlesRenderer::new(egl_context).context("error creating GlesRenderer")?;
let dummy_texture = renderer
.create_buffer(Fourcc::Abgr8888, Size::from((1, 1)))
.context("error creating dummy texture")?;
resources::init(&mut renderer);
shaders::init(&mut renderer);
Ok(renderer)
}
unsafe fn with_framebuffer_save_restore<T>(
renderer: &mut GlesRenderer,
f: impl FnOnce(&mut GlesRenderer) -> T,
) -> anyhow::Result<T> {
let mut framebuffer = 0;
renderer
.with_context(|gl| unsafe {
gl.GetIntegerv(
smithay::backend::renderer::gles::ffi::FRAMEBUFFER_BINDING,
&mut framebuffer,
);
})
.context("error running closure in GL context")?;
ensure!(framebuffer != 0, "error getting the framebuffer");
let rv = f(renderer);
renderer.unbind().context("error unbinding")?;
renderer
.with_context(|gl| unsafe {
gl.BindFramebuffer(
smithay::backend::renderer::gles::ffi::FRAMEBUFFER,
framebuffer as u32,
);
})
.context("error running closure in GL context")?;
Ok(rv)
Ok(RendererData {
renderer,
dummy_texture,
})
}
}

2
niri-visual-tests/src/test_window.rs
View File

@@ -11,7 +11,7 @@ use niri::render_helpers::solid_color::{SolidColorBuffer, SolidColorRenderElemen
use niri::render_helpers::{RenderTarget, SplitElements};
use niri::utils::transaction::Transaction;
use niri::window::ResolvedWindowRules;
use smithay::backend::renderer::element::{Id, Kind};
use smithay::backend::renderer::element::Kind;
use smithay::output::{self, Output};
use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
use smithay::utils::{Logical, Point, Scale, Serial, Size, Transform};

7
src/backend/tty.rs
View File

@@ -28,7 +28,7 @@ use smithay::backend::libinput::{LibinputInputBackend, LibinputSessionInterface}
use smithay::backend::renderer::gles::GlesRenderer;
use smithay::backend::renderer::multigpu::gbm::GbmGlesBackend;
use smithay::backend::renderer::multigpu::{GpuManager, MultiFrame, MultiRenderer};
use smithay::backend::renderer::{DebugFlags, ImportDma, ImportEgl, Renderer};
use smithay::backend::renderer::{DebugFlags, ImportDma, ImportEgl, RendererSuper};
use smithay::backend::session::libseat::LibSeatSession;
use smithay::backend::session::{Event as SessionEvent, Session};
use smithay::backend::udev::{self, UdevBackend, UdevEvent};
@@ -101,15 +101,16 @@ pub type TtyRenderer<'render> = MultiRenderer<
GbmGlesBackend<GlesRenderer, DrmDeviceFd>,
>;
pub type TtyFrame<'render, 'frame> = MultiFrame<
pub type TtyFrame<'render, 'frame, 'buffer> = MultiFrame<
'render,
'render,
'frame,
'buffer,
GbmGlesBackend<GlesRenderer, DrmDeviceFd>,
GbmGlesBackend<GlesRenderer, DrmDeviceFd>,
>;
pub type TtyRendererError<'render> = <TtyRenderer<'render> as Renderer>::Error;
pub type TtyRendererError<'render> = <TtyRenderer<'render> as RendererSuper>::Error;
type GbmDrmCompositor = DrmCompositor<
GbmAllocator<DrmDeviceFd>,

16
src/backend/winit.rs
View File

@@ -190,12 +190,16 @@ impl Winit {
}
// Hand them over to winit.
self.backend.bind().unwrap();
let age = self.backend.buffer_age().unwrap();
let res = self
.damage_tracker
.render_output(self.backend.renderer(), age, &elements, [0.; 4])
.unwrap();
let res = {
let (renderer, mut framebuffer) = self.backend.bind().unwrap();
// FIXME: currently impossible to call due to a mutable borrow.
//
// let age = self.backend.buffer_age().unwrap();
let age = 0;
self.damage_tracker
.render_output(renderer, &mut framebuffer, age, &elements, [0.; 4])
.unwrap()
};
niri.update_primary_scanout_output(output, &res.states);

6
src/niri.rs
View File

@@ -33,7 +33,7 @@ use smithay::backend::renderer::element::{
};
use smithay::backend::renderer::gles::GlesRenderer;
use smithay::backend::renderer::sync::SyncPoint;
use smithay::backend::renderer::{Color32F, Unbind};
use smithay::backend::renderer::Color32F;
use smithay::desktop::utils::{
bbox_from_surface_tree, output_update, send_dmabuf_feedback_surface_tree,
send_frames_surface_tree, surface_presentation_feedback_flags_from_states,
@@ -4536,10 +4536,6 @@ impl Niri {
}
};
if let Err(err) = renderer.unbind() {
warn!("error unbinding after rendering for screencopy: {err:?}");
}
Ok((sync, damages))
}

4
src/render_helpers/border.rs
View File

@@ -277,7 +277,7 @@ impl Element for BorderRenderElement {
impl RenderElement<GlesRenderer> for BorderRenderElement {
fn draw(
&self,
frame: &mut GlesFrame<'_>,
frame: &mut GlesFrame<'_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
@@ -294,7 +294,7 @@ impl RenderElement<GlesRenderer> for BorderRenderElement {
impl<'render> RenderElement<TtyRenderer<'render>> for BorderRenderElement {
fn draw(
&self,
frame: &mut TtyFrame<'_, '_>,
frame: &mut TtyFrame<'_, '_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],

4
src/render_helpers/clipped_surface.rs
View File

@@ -218,7 +218,7 @@ impl<R: NiriRenderer> Element for ClippedSurfaceRenderElement<R> {
impl RenderElement<GlesRenderer> for ClippedSurfaceRenderElement<GlesRenderer> {
fn draw(
&self,
frame: &mut GlesFrame<'_>,
frame: &mut GlesFrame<'_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
@@ -242,7 +242,7 @@ impl<'render> RenderElement<TtyRenderer<'render>>
{
fn draw(
&self,
frame: &mut TtyFrame<'render, '_>,
frame: &mut TtyFrame<'render, '_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],

2
src/render_helpers/damage.rs
View File

@@ -65,7 +65,7 @@ impl Element for ExtraDamage {
impl<R: Renderer> RenderElement<R> for ExtraDamage {
fn draw(
&self,
_frame: &mut <R as Renderer>::Frame<'_>,
_frame: &mut R::Frame<'_, '_>,
_src: Rectangle<f64, Buffer>,
_dst: Rectangle<i32, Physical>,
_damage: &[Rectangle<i32, Physical>],

35
src/render_helpers/mod.rs
View File

@@ -6,7 +6,7 @@ use smithay::backend::allocator::dmabuf::Dmabuf;
use smithay::backend::allocator::{Buffer, Fourcc};
use smithay::backend::renderer::element::utils::{Relocate, RelocateRenderElement};
use smithay::backend::renderer::element::{Kind, RenderElement};
use smithay::backend::renderer::gles::{GlesMapping, GlesRenderer, GlesTexture};
use smithay::backend::renderer::gles::{GlesMapping, GlesRenderer, GlesTarget, GlesTexture};
use smithay::backend::renderer::sync::SyncPoint;
use smithay::backend::renderer::{Bind, Color32F, ExportMem, Frame, Offscreen, Renderer};
use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
@@ -197,15 +197,18 @@ pub fn render_to_texture(
let buffer_size = size.to_logical(1).to_buffer(1, Transform::Normal);
let texture: GlesTexture = renderer
let mut texture: GlesTexture = renderer
.create_buffer(fourcc, buffer_size)
.context("error creating texture")?;
renderer
.bind(texture.clone())
.context("error binding texture")?;
let sync_point = {
let mut target = renderer
.bind(&mut texture)
.context("error binding texture")?;
render_elements(renderer, &mut target, size, scale, transform, elements)?
};
let sync_point = render_elements(renderer, size, scale, transform, elements)?;
Ok((texture, sync_point))
}
@@ -219,11 +222,16 @@ pub fn render_and_download(
) -> anyhow::Result<GlesMapping> {
let _span = tracy_client::span!();
let (_, _) = render_to_texture(renderer, size, scale, transform, fourcc, elements)?;
let (mut texture, _) = render_to_texture(renderer, size, scale, transform, fourcc, elements)?;
let buffer_size = size.to_logical(1).to_buffer(1, Transform::Normal);
// FIXME: would be nice to avoid binding the second time here (after render_to_texture()), but
// borrowing makes this invonvenient.
let target = renderer
.bind(&mut texture)
.context("error binding texture")?;
let mapping = renderer
.copy_framebuffer(Rectangle::from_size(buffer_size), fourcc)
.copy_framebuffer(&target, Rectangle::from_size(buffer_size), fourcc)
.context("error copying framebuffer")?;
Ok(mapping)
}
@@ -248,7 +256,7 @@ pub fn render_to_vec(
pub fn render_to_dmabuf(
renderer: &mut GlesRenderer,
dmabuf: Dmabuf,
mut dmabuf: Dmabuf,
size: Size<i32, Physical>,
scale: Scale<f64>,
transform: Transform,
@@ -259,8 +267,10 @@ pub fn render_to_dmabuf(
dmabuf.width() == size.w as u32 && dmabuf.height() == size.h as u32,
"invalid buffer size"
);
renderer.bind(dmabuf).context("error binding texture")?;
render_elements(renderer, size, scale, transform, elements)
let mut target = renderer
.bind(&mut dmabuf)
.context("error binding texture")?;
render_elements(renderer, &mut target, size, scale, transform, elements)
}
pub fn render_to_shm(
@@ -301,6 +311,7 @@ pub fn render_to_shm(
fn render_elements(
renderer: &mut GlesRenderer,
target: &mut GlesTarget,
size: Size<i32, Physical>,
scale: Scale<f64>,
transform: Transform,
@@ -310,7 +321,7 @@ fn render_elements(
let output_rect = Rectangle::from_size(transform.transform_size(size));
let mut frame = renderer
.render(size, transform)
.render(target, size, transform)
.context("error starting frame")?;
frame

4
src/render_helpers/offscreen.rs
View File

@@ -171,7 +171,7 @@ impl Element for OffscreenRenderElement {
impl RenderElement<GlesRenderer> for OffscreenRenderElement {
fn draw(
&self,
frame: &mut GlesFrame<'_>,
frame: &mut GlesFrame<'_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
@@ -212,7 +212,7 @@ impl RenderElement<GlesRenderer> for OffscreenRenderElement {
impl<'render> RenderElement<TtyRenderer<'render>> for OffscreenRenderElement {
fn draw(
&self,
frame: &mut TtyFrame<'_, '_>,
frame: &mut TtyFrame<'_, '_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],

4
src/render_helpers/primary_gpu_texture.rs
View File

@@ -56,7 +56,7 @@ impl Element for PrimaryGpuTextureRenderElement {
impl RenderElement<GlesRenderer> for PrimaryGpuTextureRenderElement {
fn draw(
&self,
frame: &mut GlesFrame<'_>,
frame: &mut GlesFrame<'_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
@@ -77,7 +77,7 @@ impl RenderElement<GlesRenderer> for PrimaryGpuTextureRenderElement {
impl<'render> RenderElement<TtyRenderer<'render>> for PrimaryGpuTextureRenderElement {
fn draw(
&self,
frame: &mut TtyFrame<'_, '_>,
frame: &mut TtyFrame<'_, '_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],

4
src/render_helpers/render_elements.rs
View File

@@ -99,7 +99,7 @@ macro_rules! niri_render_elements {
{
fn draw(
&self,
frame: &mut smithay::backend::renderer::gles::GlesFrame<'_>,
frame: &mut smithay::backend::renderer::gles::GlesFrame<'_, '_>,
src: smithay::utils::Rectangle<f64, smithay::utils::Buffer>,
dst: smithay::utils::Rectangle<i32, smithay::utils::Physical>,
damage: &[smithay::utils::Rectangle<i32, smithay::utils::Physical>],
@@ -124,7 +124,7 @@ macro_rules! niri_render_elements {
{
fn draw(
&self,
frame: &mut $crate::backend::tty::TtyFrame<'render, '_>,
frame: &mut $crate::backend::tty::TtyFrame<'render, '_, '_>,
src: smithay::utils::Rectangle<f64, smithay::utils::Buffer>,
dst: smithay::utils::Rectangle<i32, smithay::utils::Physical>,
damage: &[smithay::utils::Rectangle<i32, smithay::utils::Physical>],

19
src/render_helpers/renderer.rs
View File

@@ -1,7 +1,7 @@
use smithay::backend::allocator::dmabuf::Dmabuf;
use smithay::backend::renderer::gles::{GlesFrame, GlesRenderer, GlesTexture};
use smithay::backend::renderer::{
Bind, ExportMem, ImportAll, ImportMem, Offscreen, Renderer, Texture,
Bind, ExportMem, ImportAll, ImportMem, Offscreen, Renderer, RendererSuper, Texture,
};
use crate::backend::tty::{TtyFrame, TtyRenderer};
@@ -21,7 +21,7 @@ pub trait NiriRenderer:
type NiriError: std::error::Error
+ Send
+ Sync
+ From<<GlesRenderer as Renderer>::Error>
+ From<<GlesRenderer as RendererSuper>::Error>
+ 'static;
}
@@ -29,7 +29,8 @@ impl<R> NiriRenderer for R
where
R: ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + Offscreen<GlesTexture> + AsGlesRenderer,
R::TextureId: Texture + Clone + Send + 'static,
R::Error: std::error::Error + Send + Sync + From<<GlesRenderer as Renderer>::Error> + 'static,
R::Error:
std::error::Error + Send + Sync + From<<GlesRenderer as RendererSuper>::Error> + 'static,
{
type NiriTextureId = R::TextureId;
type NiriError = R::Error;
@@ -53,21 +54,21 @@ impl AsGlesRenderer for TtyRenderer<'_> {
}
/// Trait for getting the underlying `GlesFrame`.
pub trait AsGlesFrame<'frame>
pub trait AsGlesFrame<'frame, 'buffer>
where
Self: 'frame,
{
fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame>;
fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame, 'buffer>;
}
impl<'frame> AsGlesFrame<'frame> for GlesFrame<'frame> {
fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame> {
impl<'frame, 'buffer> AsGlesFrame<'frame, 'buffer> for GlesFrame<'frame, 'buffer> {
fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame, 'buffer> {
self
}
}
impl<'frame> AsGlesFrame<'frame> for TtyFrame<'_, 'frame> {
fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame> {
impl<'frame, 'buffer> AsGlesFrame<'frame, 'buffer> for TtyFrame<'_, 'frame, 'buffer> {
fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame, 'buffer> {
self.as_mut()
}
}

4
src/render_helpers/resize.rs
View File

@@ -163,7 +163,7 @@ impl Element for ResizeRenderElement {
impl RenderElement<GlesRenderer> for ResizeRenderElement {
fn draw(
&self,
frame: &mut GlesFrame<'_>,
frame: &mut GlesFrame<'_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
@@ -181,7 +181,7 @@ impl RenderElement<GlesRenderer> for ResizeRenderElement {
impl<'render> RenderElement<TtyRenderer<'render>> for ResizeRenderElement {
fn draw(
&self,
frame: &mut TtyFrame<'_, '_>,
frame: &mut TtyFrame<'_, '_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],

4
src/render_helpers/shader_element.rs
View File

@@ -283,7 +283,7 @@ impl Element for ShaderRenderElement {
impl RenderElement<GlesRenderer> for ShaderRenderElement {
fn draw(
&self,
frame: &mut GlesFrame<'_>,
frame: &mut GlesFrame<'_, '_>,
src: Rectangle<f64, Buffer>,
dest: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
@@ -514,7 +514,7 @@ impl RenderElement<GlesRenderer> for ShaderRenderElement {
impl<'render> RenderElement<TtyRenderer<'render>> for ShaderRenderElement {
fn draw(
&self,
frame: &mut TtyFrame<'_, '_>,
frame: &mut TtyFrame<'_, '_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],

2
src/render_helpers/shaders/mod.rs
View File

@@ -107,7 +107,7 @@ impl Shaders {
}
}
pub fn get_from_frame<'a>(frame: &'a mut GlesFrame<'_>) -> &'a Self {
pub fn get_from_frame<'a>(frame: &'a mut GlesFrame<'_, '_>) -> &'a Self {
let data = frame.egl_context().user_data();
data.get()
.expect("shaders::init() must be called when creating the renderer")

4
src/render_helpers/shadow.rs
View File

@@ -233,7 +233,7 @@ impl Element for ShadowRenderElement {
impl RenderElement<GlesRenderer> for ShadowRenderElement {
fn draw(
&self,
frame: &mut GlesFrame<'_>,
frame: &mut GlesFrame<'_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
@@ -250,7 +250,7 @@ impl RenderElement<GlesRenderer> for ShadowRenderElement {
impl<'render> RenderElement<TtyRenderer<'render>> for ShadowRenderElement {
fn draw(
&self,
frame: &mut TtyFrame<'_, '_>,
frame: &mut TtyFrame<'_, '_, '_>,
src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],

4
src/render_helpers/solid_color.rs
View File

@@ -153,12 +153,12 @@ impl Element for SolidColorRenderElement {
impl<R: Renderer> RenderElement<R> for SolidColorRenderElement {
fn draw(
&self,
frame: &mut <R as Renderer>::Frame<'_>,
frame: &mut R::Frame<'_, '_>,
_src: Rectangle<f64, Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
_opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), <R as Renderer>::Error> {
) -> Result<(), R::Error> {
frame.draw_solid(dst, damage, self.color)
}

8
src/render_helpers/texture.rs
View File

@@ -58,7 +58,7 @@ impl<T> TextureBuffer<T> {
scale: impl Into<Scale<f64>>,
transform: Transform,
opaque_regions: Vec<Rectangle<i32, Buffer>>,
) -> Result<Self, <R as Renderer>::Error> {
) -> Result<Self, R::Error> {
let texture = renderer.import_memory(data, format, size.into(), flipped)?;
Ok(TextureBuffer::from_texture(
renderer,
@@ -72,7 +72,7 @@ impl<T> TextureBuffer<T> {
pub fn from_memory_buffer<R: Renderer<TextureId = T> + ImportMem>(
renderer: &mut R,
buffer: &MemoryBuffer,
) -> Result<Self, <R as Renderer>::Error> {
) -> Result<Self, R::Error> {
Self::from_memory(
renderer,
buffer.data(),
@@ -213,12 +213,12 @@ where
{
fn draw(
&self,
frame: &mut <R as Renderer>::Frame<'_>,
frame: &mut R::Frame<'_, '_>,
src: Rectangle<f64, Buffer>,
dest: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
opaque_regions: &[Rectangle<i32, Physical>],
) -> Result<(), <R as Renderer>::Error> {
) -> Result<(), R::Error> {
if frame.id() != self.buffer.renderer_id {
warn!("trying to render texture from different renderer");
return Ok(());